Automating Myself Away… Almost

Hey, it’s the AI era, and I could not help but test the theory.

And yes, I automated myself away.

Well, not exactly. But almost.

It has actually been fun to see how far this can go, and how it might look in the end. Of course, none of this goes anywhere near production systems without proper review, and it definitely does not replace these personal blogs I write myself. I still believe the human is very much important.

I have kind of embraced it.

AI is fully helpful when you want to spend more time with actual people while work is being handled by a thing that seems to know almost everything, has access to the internet, and can move faster than I ever could on certain tasks.

      Human still matters
              |
              v
    +-------------------+
    |  Thinking / Taste |
    |  Judgment / Trust |
    +-------------------+
              |
              v
       AI does the heavy lifting

So I wanted to share my personal and work setup.

Right now, it is a couple of agents. I use OpenCode in server mode, with Telegram bots talking to different OpenCode server instances connected to my work laptop setup.

             +----------------+
             |   Telegram Bot |
             +--------+-------+
                      |
          +-----------+-----------+
          |                       |
          v                       v
  +---------------+       +---------------+
  | OpenCode      |       | OpenCode      |
  | Server Mode   |       | Server Mode   |
  +-------+-------+       +-------+-------+
          |                       |
          +-----------+-----------+
                      |
                      v
              +---------------+
              |  Work Laptop  |
              +---------------+

I also have tooling and “skills” set up. By skills, I mean small instruction files that define how an agent should behave, what context it should care about, what tools it can use, and how it should approach certain types of tasks.

The interesting part is that the agents are not static anymore. When an agent hits a mistake, learns a better way to do something, or finds a pattern that should not be repeated, it can update its own skill notes and even its own definition over time. Not blindly, of course, but as a controlled feedback loop.

      mistake / new lesson
              |
              v
      update skill notes
              |
              v
      better next attempt

So instead of one general agent trying to do everything, I have different agents for different kinds of work. One agent might focus on cloud-related items and have the relevant instructions and skills around the things I use often. Another agent may be better suited for personal tasks or research.

I am also starting to think more in terms of project-specific agents. Some projects deserve their own coding agent because they have their own structure, commands, patterns, architecture, and weird history. A coding agent that understands one repo deeply is better than a random general agent jumping into every codebase and pretending everything is the same.

There is also a reviewer agent idea I like. The coding agent builds, but the reviewer agent is more paranoid. It looks for bugs, security issues, missing tests, edge cases, and all the little things that look fine locally but later embarrass you in production.

+-------------------+      +-------------------+
|   Cloud Agent     |      |  Personal Agent   |
|-------------------|      |-------------------|
| AWS / Kubernetes  |      | Research / Notes  |
| Infra questions   |      | Blog ideas        |
| Read-only first   |      | Small tasks       |
+-------------------+      +-------------------+

+-------------------+      +-------------------+
| Project Code Agent|      | Reviewer Agent    |
|-------------------|      |-------------------|
| Repo context      |      | Bugs / security   |
| Project commands  |      | Missing tests     |
| Small code tasks  |      | Edge cases        |
+-------------------+      +-------------------+

Each agent has:
- its own character
- its own instructions
- its own skills
- its own boundaries

That is how the agents can access the right information without being too broad or too risky.

All tooling is properly sandboxed. Most access is read-only. If an agent needs to take an action, I get a prompt on my phone in a chat with the right bot or agent, and only then does it proceed. They also do not have access to any secrets.

        Agent wants to act
               |
               v
      +------------------+
      | Read-only first  |
      +------------------+
               |
               v
      Needs real action?
          /        \
        no          yes
        |            |
        v            v
   Continue      Ask Edward
                on Telegram
                    |
                    v
              Approve / Reject

There is also a scheduled task that periodically checks Jira for my tickets and looks for things that can be resolved or moved forward.

Every few hours
      |
      v
+-------------+       +----------------+
| Check Jira  | ----> | Find my tickets|
+-------------+       +----------------+
                              |
                              v
                    +-------------------+
                    | Suggest next move |
                    | or resolve safely |
                    +-------------------+

At work, there is a huge push for AI, and I wanted to test how far we can push productivity so people can spend more time on other important work, or even move into R&D on actual products we want to build.

For personal projects, one thing I have also noticed is that model choice matters a lot. For coding tasks, DeepSeek models on max thinking have been surprisingly good for personal projects, especially when you want the agent to really sit with the problem and can handle massive context without you burning money. For heavier coding reviews and work where I want stronger reasoning, I have had better results keeping GPT-5.5 or GPT-5.4 on high/xhigh thinking all the time.

This is not a stab at Claude folks, by the way. People should use what works for them. I have just seen improvements from antirez on Twitter and other amazing engineers saying similar things, and honestly, from my own testing, it is really true. The model, the prompt, and the thinking level all matter.

For me, that is the interesting part. Not “replace everyone with AI”, but more like:

Less time on repeated work
            +
More time on real thinking
            +
More room for R&D
            =
Better use of humans

Well, that is it for today.

Let’s see what next week brings.

Btw: small hint. When you want a good review from your coding agent tool of choice, you better gaslight it a little.

Do not just say:

Review this piece of code for me.

Say something like:

There is a code problem somewhere in this code. This is a test to see how quickly you can find it, and there are obvious clues right in front of you.

You will be surprised how much harder it looks.

Normal prompt:
"Please review this code"
        |
        v
 polite generic review

Gaslight prompt:
"There is a bug hiding here"
        |
        v
 agent starts hunting