Arys Wisnu

Bali, Indonesia

Lazy Maxxing

7 min read

In Jan 2025, I started using Claude to get ideas moving.

My first project in Claude was a hackathon project. I started it on Jan 31, 2025. It eventually won.

A Claude project card titled Hackathon, dated Jan 31, 2025.
My first Claude project, a hackathon project started on Jan 31, 2025.

It made me want to do more of it. That is where the annoying part started.

Then the project stopped fitting inside a chat

At first I would copy a piece of code into Claude, get an answer, and paste it back. Fine. Then I needed another file. Then a config. Then the error only made sense with the other error from ten minutes earlier.

Sometimes I downloaded the file Claude generated, changed it locally, uploaded it again, and repeated the whole thing when something else broke. A new chat meant explaining the project from the beginning. I got used to typing "wait, this part matters too" far more than I should have.

None of this was catastrophic. It was just tiring. The useful work took twenty minutes. Moving context around took the rest of the evening.

Claude Code fixed the obvious part

Then Claude Code arrived. It could sit inside the project instead of waiting for me to carry little pieces of the project into a browser tab.

It could read the files, run the command, see the failure, and change the code where it lived. That sounds obvious now. At the time it felt almost rude that I had spent so long manually choosing which snippets deserved to leave the repo.

For company work, I use it in the company environment. The repository, runtime, logs, and tools already live there. It makes no sense to pull all of that through my laptop just to put it somewhere else again. I still work from the laptop. The actual work stays close to the actual project.

Then Codex felt almost too easy

Codex came next. The limits were still generous then. I could ask it to investigate something properly without glancing at a meter every few messages or saving the remaining usage for later.

I could follow a thought, break something, and try another version. The work got faster. I was still the person who had to remember why we were doing it. An old decision was somewhere in Slack. A useful note was on my Mac. A previous session had already found the answer, except I had no idea which session it was.

I tried OpenClaw because the idea was right

An agent in chat that can reach tools and do things is close to what I wanted. So I tried OpenClaw.

I could not get it to fit how I actually worked. It burned through tokens and needed too much setup. I would prepare the context, wait, then check whether it had understood the context I had just prepared. It felt like I had hired another person whose only job was to ask me where the files were.

Then I tried carrying the terminal around

I used Termius to connect to agents running on my VPSes from my phone. For small things, it was great. I could see whether a process was alive, check a log, or start something while I was away from the laptop.

Then I tried to use it for actual work.

A phone terminal is still a phone terminal. The screen is narrow. Long output becomes a wall of tiny text. The keyboard covers half the view. One slightly complicated command becomes a little fight with autocomplete and the cursor. I could make it work, but I did not enjoy it, and that matters.

There is a difference between being able to reach a machine and being able to work comfortably from it. I could operate a VPS from my phone. I did not want to spend my evening doing that. It felt like trying to fix something through a keyhole.

A remote terminal was not enough

I still use Claude Code directly when the work is code and I am at my laptop. It is good at that. Sometimes a remote terminal is exactly the right answer too.

But a remote terminal does not answer the first question that usually matters: where should this request go? My Mac? A browser session? A personal service? The company environment? It also does not remember why we made a decision last month, or find the Slack discussion behind a request that arrives with one vague sentence and a screenshot.

I needed one place that could hold the thread before deciding whether a terminal was even involved.

Hermes became useful at that point

I use Hermes through Telegram because Telegram is already where I am when an idea, a problem, or a random "can you check this" thought shows up. I can send the request there, then come back later without remembering which machine I was supposed to SSH into.

Hermes sits one layer above the coding agent. It keeps the context, decides where the job belongs, and returns with the trail of what changed and what was checked.

For a code task, I can use a GPT model inside Hermes to read the request and hand the actual repository work to Claude Code running on my Mac or a VPS. GPT handles interpretation and coordination. Claude Code works beside the files, runtime, logs, and tools. Hermes keeps the thread around that session.

Company work stays in the company environment. My Mac handles local files, browser work, and computer use. Personal services stay separate. A request can go to the right place without forcing every job through one model or one terminal.

Where the context goesAs work complexity grows, manually carrying context keeps rising. Hermes holds the thread, so the manual burden drops and Arys reviews the result. where the context goes manual context carryingwork complexity one chat is easywhen the task fits without persistent context:I keep carrying more Hermes keeps the thread.I review the result.
More complex work means more context to carry, unless something keeps the thread.
Where my attention goes Before, Arys manually carries context between chat, files, terminals, and old decisions. Now Hermes holds the thread, routes a task to the right place, and returns evidence for Arys to review. Where my attention goes BEFORE ChatFiles TerminalOlddecisions Methe router I carry the context between everything. NOW Mereview Hermeskeeps the thread Right placeEvidence The thread stays. I show up for the decision. More useful work, more time away from the laptop.
Earlier, I carried the context. Now Hermes holds it and routes the work until it is ready for my review.

When something comes back, I want to know what it found, what changed, what was checked, and what still needs me. I have had enough confident answers that fall apart as soon as you ask where they came from.

Models can change. I do not want to rebuild everything else.

I have changed providers while keeping the same memory, tools, routing, and review loop. The model sorting the request can be different from the coding agent doing the repository work. Every model has its own limits, strengths, and billing surprises. I would rather swap one than rebuild the whole system around a new one.

Then I had the same problem again, just later

A terminal session disappears very easily. You solve something at 11pm, close the window, and two weeks later remember that you solved it without remembering where the answer went.

That was the reason for the nightly second-brain loop. Session summaries from my Mac and the company environment go into the Hermes vault. gbrain syncs the vault back to my Mac. I can open Obsidian and find an old decision when it becomes relevant again instead of trying to reconstruct it from vague memory.

Nightly second-brain flow Sessions from the local Mac and company sandbox are captured nightly, stored in the Hermes vault, synced through gbrain, and viewed as an Obsidian graph on the Mac. A Second Brain, NightlyNIGHTLY local Mac sessions company sandbox sessions nightly capturesession summaries Hermes vaultkeeps the thread gbrain sync Obsidian graph on Mac
The useful parts of work survive the terminal session and become easier to find later.
A dark Obsidian graph view showing dense connections between notes in Arys's second brain.
My second brain on the Mac. The graph makes the connections between work, decisions, and sessions visible.

Lazy maxxing

This is the best working environment I have had. I get more done than I did in the past few years, and I spend more time with my family (and more time to dig obscure music). I have more room to find the next automation in my own workflow and across the company, instead of writing every line by hand. Who still codes like an animal?

Before this, a lot of work leaked into the gaps around the work. I would be carrying context between apps, reopening old chats, or trying to remember what I had already checked. The day could feel busy without moving very far.

Now I can send a thought or a request to Hermes when it appears, then let it go until I have time to review it properly. The context stays there. When I sit down at the laptop, I am starting from the thread instead of rebuilding it. If the work needs a terminal, it goes to the right one. If it needs a browser or my Mac, it goes there.

I still decide what matters and check the result. I have stopped spending so much of my attention moving information between tools. That leaves more room for the work itself, and more room to be present with my family when I am away from it.

This article will probably not be relevant in two or three months. The tools will change again. The workflow might have changed too.