Blog / Article 005
Rse Is Overkill. That's the Point. Until It Isn't.
How I learned to love complex systems, started asking "why?", and why I'm still not giving up on ambitious ideas.
GTA VI is here. And with that, I'd like to congratulate everyone! We've finally made it to this historic moment. 😄
I have my own queue of long-awaited releases too: Reliverse tools, Bleverse platforms, and Rse agents. Today I want to talk about the last of those, and why trying to make agents powerful can get in the way of making them pleasant to use.
On this page: I love overkill · A small problem, another new tool · When "make it secure" creates another system · Three kinds of overkill · Campaign003: when I started saying no · So why am I still building Rse? · What's behind a simple "can I publish this?" · What it should feel like to use · De-overkill doesn't mean "throw out the safety checks" · AI shouldn't be a crutch for bad DX · And still: Rse Is Overkill
I love overkill
I like imagining tools that millions of people might use someday, even though right now the main users of many of mine are me and my AI agents.
I enjoy designing libraries, exploring unusual architectures, and wondering how one small idea could become the foundation for an entire ecosystem.
I don't think that's a bad thing.
It becomes a problem when the architecture for an imaginary million users stops the first real user from doing something simple.
Especially when that first user is me, and I already need another agent to explain how to use my own CLI. 🫠
In the earlier articles, I introduced Reliverse, Rse, and Bleverse, told my story, and explained how publishing some code turned into GR Campaigns. Now I want to talk about the contradiction underneath all of it: how do I keep the big ambitions without making everyday users suffer for them?
A small problem, another new tool
I've had a habit of building tools for my tools for years.
Wanted nicer terminal output? I'd start experimenting with a library.
Wanted to build and publish libraries without repeating the same steps? I'd start creating a CLI.
Wanted a better way to build CLIs? A new command and prompt system would grow around it.
Wanted AI agents to use those tools? Time for ideas about an agent environment.
That's the short version of Article 002.
But to be fair, I had this habit long before coding agents. In 2023, I tried squeezing different databases, ORMs, auth systems, and UI tools into one Next.js starter called Relivator. By the 2024 v1.2.6 release, its package.json looked like a small spacecraft control panel: scripts for migrations, checks, builds, updates, cleanup, and several flavors of the same operation.
Meanwhile, the CLI kept changing: Go in March 2024, TypeScript and Bun in April, then further experiments with Go and Rust, followed by a decision to remove them from that version of Rse in October 2025. This isn't some universal rule that Bun is good and everything else is bad. It's a record of me trying to balance useful capabilities against the cost of maintaining them.
At least my experiments used to be limited by how much code I could write myself. Then modern coding agents arrived.
Suddenly I could prototype almost any interesting idea much faster. I'd bring a half-formed thought to ChatGPT, discuss it, question it, and work through the weak spots. Then Codex or agents running through Zed could help turn it into actual code.
I still love working this way.
In an old piece about Reliverse CLI, I even described a setting called scriptsBehavior: autoYes as yolo mode. I wanted the tool to handle the boring bits automatically. I still do, but I now see a much sharper line between safely formatting files locally and, say, deleting things or pushing changes to production. That old article was a description of what I wanted the CLI to do, not proof that every part of it worked flawlessly at the time.
But sometimes my agents and I resembled a team of people who really, really enjoyed inventing new systems and weren't always great at stopping.
When "make it secure" creates another system
I might tell an agent: "Make sure secrets are stored securely".
Perfectly reasonable request. The trouble is that, without a clear use case and boundaries, it can produce more and more layers, policies, contracts, and lifecycle machinery. Each layer seems reasonable on its own.
Then suddenly, using the result for one real task requires understanding the entire structure.
Something similar happened with tests. Occasionally an agent produced so many checks that changing Technical Details to Technical details became a bigger issue than behavior nobody had actually verified.
There were specs thousands of lines long, oversized dependency closures, and abstractions still waiting for their first real consumer.
The funniest part is that I often approved those decisions myself. Because I found them interesting.
Then came the part where I had to use the tools.
Three kinds of overkill
Eventually I started separating my own little Nazar's Overkill™ into three categories.
Useful complexity. If an agent can delete files, modify production configuration, or publish code, a well-written prompt isn't enough. You need real boundaries, checks, and a way to deny an operation.
Unnecessary complexity. Another abstraction adds no meaningful guarantee and solves no new problem, but now there's another API, configuration format, and set of docs to maintain.
Premature complexity. I can imagine a future need for a complete virtual filesystem, a universal gateway, or an elaborate simulation framework. Maybe those will make sense someday. But if I don't have one actual use case that needs them today, why am I already required to build them?
For example, I care about isolating agents' file operations. That doesn't mean I immediately need an OS-mounted VFS built on FUSE. I also want to check risky operations before executing them. That doesn't mean I need a simulator for the entire computer.
This gradually became a rule:
Think ten years ahead. Implement one real use case ahead.
Easy to say. Much harder to follow.
Campaign003: when I started saying no
During the first GR Campaigns, my agents and I worked with repositories, checks, permissions, and publication. I wanted the process controlled: prepare a change, authorize the action, verify the result.
But after Campaign003, one thing started bothering me more than anything else.
Instead of a supported command for an operation, an agent could suggest a temporary script. It would contain specific paths, filenames, environment parameters, and logic I was effectively supposed to trust without understanding.
I remember thinking:
Wait. I'm building developer tools. Why does using my developer tools keep requiring another one-off script?
Eventually I started replying with something like:
"I'm not running that hard-coded command from your temp script. Give the actual CLI a proper interface".
This isn't a war on shell scripts. If I need to rename five files in a throwaway draft once, building a new CLI command for it might be pure overkill. Scripts are great for exploration and genuinely one-off work. But a recurring, important operation with defined permissions deserves a maintained interface.
And not merely a pretty command that hides the same unsafe script. I want understandable arguments, precondition checks, proper authorization, useful errors, and a way to verify the outcome.
Sometimes that meant the agent had to write more code. But next time, the same operation wouldn't need to be invented again.
That's when I really understood the difference between automating one task and building a tool for a whole class of tasks.
So why am I still building Rse?
After all that, you might expect me to build the world's simplest CLI, throw out every gateway, and never speak of agents again.
Nope. 😄
I want Rse to help people work with files, projects, tools, apps, and services, not just chat about them. I want your own computer and data to be a proper starting point, the freedom to choose AI providers, and the option to work with other agents when that actually helps.
Without handing every plugin the keys to the entire system.
Here's a simple example: I ask Rse to inspect a project, fix some problems, and prepare the changes for publication.
It could read the relevant files, run permitted tests, edit code within the workspace, and show me the results. But preparing changes isn't permission to push them. Publishing may require different authorization and my approval.
Those are the kinds of distinctions I'm happy to keep complexity for.
What's behind a simple "can I publish this?"
I'm developing a few separate concepts in Reliverse. Not so users have to memorize them before running Rse, but so different tools don't invent incompatible permission models.
Caps describe the operations a system is capable of performing. There are three important distinctions: a capability is available, enabled in this environment, and authorized for this particular actor and resource. Those aren't the same state.
Gatehouse handles the authorization boundary: who's requesting what, on whose behalf, and under what conditions? A model can suggest a push. That doesn't mean the push is authorized. A sensitive operation might need narrowly scoped approval, not a vague "allow everything for the next half hour".
UF (RVS User Framework) concerns identity and delegation. Because an agent acting on my behalf doesn't become me. If it calls another agent or service, it matters who actually performs the action and where their permissions came from.
Rse Gateway is for interacting with other processes and systems. It builds on shared RVS Gateway Framework mechanisms; connectivity and execution have their own responsibilities, including RVS Network, RVS, and providers. But the gateway shouldn't have to run as a mandatory background server just to read a local file.
This is a compact description of the direction, not a claim that every planned scenario already works end to end in the public Rse release.
And if none of those names mean anything to you, that's fine. You shouldn't need to know them to get normal work done.
What it should feel like to use
Here's the kind of interaction I'd like:
Me: "Check my project, fix the problems, and prepare the changes for publication".
Rse: "I found some issues, fixed them, and ran the available checks. Here are the changes and results. Publishing requires your approval".
Me: "Show me exactly what would be published".
Rse: "Here's the diff, the check results, and what I couldn't verify yet".
Me: "Okay, publish it".
Then the system should perform only the authorized operation and verify whether the expected result actually happened. As I learned with GR, a local commit and a successful GitHub publication are two very different things.
Yes, quite a bit of engineering may sit behind that short conversation. But the person using the tool shouldn't have to coordinate every internal component.
And to be clear, this is the experience I'm aiming for. Some foundational contracts and individual workflows exist already, but I can't honestly call that entire interaction a finished universal product yet.
De-overkill doesn't mean "throw out the safety checks"
Once I started simplifying things seriously, I found the opposite trap: you can remove so many layers that you accidentally remove necessary guarantees too.
If an authorization wrapper adds nothing beyond a check that already exists, maybe it should go. But if it's the only place that verifies permission for a risky action, deleting it to save code is a terrible idea.
The same goes for isolation, receipts, remote readback, and recovery from failures. I'm not trying to minimize lines of code at any cost. I'm trying to minimize unjustified complexity.
I've even turned that thinking into a small skill: .agents/skills/avoid-overengineering/SKILL.md. Its point isn't to force the shortest solution. Before adding another layer, I want a few simple answers:
- Which concrete use case does it improve?
- What breaks or becomes unsafe without it?
- Is there an existing, supported way to do the same thing?
- Can we add the guarantee without creating an entire new subsystem?
Every new layer has to earn its place.
Not through a beautiful name. Not because it might be needed in ten years. And definitely not because AI can write it in five minutes.
AI shouldn't be a crutch for bad DX
There's one more trap I've started noticing.
AI can work with terrible tools. It'll read the docs, find hidden parameters, write a script, work around a strange API, and somehow get the task done.
That's impressive. It can also hide the real problem.
If an agent repeatedly has to inspect internal files and invent a new sequence of commands for a standard operation, maybe what we need isn't a smarter model. Maybe we need a better interface for the tool itself.
That's why I want Reliverse to stay useful without AI, and I don't want Rse to require a model for every tiny task. Building my own tools has taught me something else, too: not every pain point needs a new framework. Sometimes the answer is a better command, a clearer error message, or the freedom to swap one dependency for another.
In an old essay about JavaScript tooling, I was already circling a similar question: what does switching tools actually cost? Sometimes a clear error, compatibility, or a manageable migration path matters more than another shiny benchmark. I'd like to explore that separately, including through the package-manager rabbit hole.
A good CLI should be a good CLI. A good API should be a good API. An agent should extend what they can do, not excuse how awkward they are to use.
And still: Rse Is Overkill
Yes, in a sense, Rse is still overkill. I want it to eventually connect simple local tasks with harder scenarios involving different models, machines, services, and delegated permissions.
But I have a clearer boundary now.
Think ten years ahead. Implement one real use case ahead.
Not every possible future feature deserves to be built today. And the ones that genuinely matter shouldn't make simple things miserable.
As a kid, I built little worlds in GTA and imagined an internet out of folders. Later, programming gave me a way to turn ideas into things I could interact with. I'm still doing roughly that, only the tools are more powerful and AI helps me explore more of those ideas.
And I'm increasingly convinced that the value of these systems isn't in how much complexity they can create.
It's in how much complexity they can take on so people have more freedom left to create.
That applies to Rse, Reliverse, and ultimately Bleverse. People don't come for my contracts, gateways, or fancy names. They come to make something of their own.
Overkill on the inside. Simplicity on the outside. 🜂
Author: blefnk · Language: English · Series: Introducing Bleverse
Previous article · All published articles