<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>AI on lubieniebieski by adam nowak</title>
    <link>https://lubieniebieski.pl/tags/ai/</link>
    <description>Recent content in AI on lubieniebieski by adam nowak</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Mon, 16 Nov 2026 20:31:08 +0100</lastBuildDate><atom:link href="https://lubieniebieski.pl/tags/ai/feed.xml" rel="self" type="application/rss+xml" />
    
    
    

    <item>
      <title>Working with agents: my setup (Nov 2026)</title>
      <link>https://lubieniebieski.pl/posts/2026/11/working-with-agents/</link>
      <pubDate>Mon, 16 Nov 2026 20:31:08 +0100</pubDate>
      
      <guid>https://lubieniebieski.pl/posts/2026/11/working-with-agents/</guid>
      <description><![CDATA[<p>In <a href="/bullets/24/">Bullets #24</a> I wrote that I went all in with AI in my side projects. A few weeks later, it&rsquo;s not only about writing code anymore. I spent the last week or two testing different ways of working with agents, and I keep asking myself one question: where should I invest my time?</p>
<ul>
<li>Should I build a comfy terminal setup for running and watching agents and managing workspaces?</li>
<li>Or should I simply talk through a task with an agent first and then let it do the whole implementation on its own?</li>
</ul>
<p>The honest answer for now is: it depends 🤷🏻‍♂️. But one thing is clear - good tooling helps in both cases.</p>
<blockquote class="panel info">
  A quick disclaimer. A few months ago my problems were on a completely different level, and the area that deserves the most attention keeps changing really fast. Everyone has their own context, too. I know the situation looks different for people who go full tokenmaxxing than for hobby users who just want to build something on weekends. Here I describe both my home and work contexts, so I hope you can pick up at least a few starting points for your own tests. Because honestly, these days I don&rsquo;t have a better piece of advice than this: experiment! 💪🏻
</blockquote>

<h2 id="tools-im-testing">Tools I&rsquo;m testing</h2>
<h3 id="herdr">Herdr</h3>
<p>I&rsquo;ve been using <a href="https://herdr.dev/">Herdr</a> for a few months now. The way it&rsquo;s built suits my workflow and expectations I didn&rsquo;t even know I had. The original version (which still works perfectly fine) is a terminal app that behaves like tmux, so I can use it everywhere, including limited environments like VPSs or machines where I&rsquo;m not allowed to install new desktop apps.</p>
<p>Recently it became more than a TUI - it&rsquo;s now also a proper desktop app built on top of <a href="https://ghostty.org/">Ghostty</a>, which I already like and use. It also supports agents well, and you can customize it with mods and plugins. After a few small tweaks, I got the setup I wanted - seeing my workspaces, having an overview of all pull requests and their status, seeing the agents&rsquo; token usage, and being able to connect to external machines.</p>
<h3 id="orca">Orca</h3>
<p><a href="https://orca.dev/">Orca</a> made a really good impression on me and it will most likely stay for longer tests. It has much more built in:</p>
<ul>
<li>workspaces based on git worktrees, with their whole lifecycle managed for you,</li>
<li>hooks for creating and archiving workspaces,</li>
<li>integrations with GitHub Issues, Linear and Jira - you open a context, point to a ticket and hand the work over to an agent,</li>
<li>a skill, so the agent itself can manage sessions,</li>
<li>cronjob-like automations.</li>
</ul>
<p>It really feels like an ADE (Agentic Development Environment). There&rsquo;s no doubt about it - it has an integrated browser, a mobile simulator and dozens of other things. You get quite a lot from the start, which is the opposite of what I was used to with Herdr.</p>
<h3 id="hermes">Hermes</h3>
<p>I don&rsquo;t know yet if <a href="https://hermes-agent.nousresearch.com/">Hermes</a> will stay. Maybe it will be more useful outside of coding - for my <a href="/bullets/23/">homelab</a>, the house, Home Assistant and automations in general. Talking to it via Telegram and other messengers is a nice touch. I&rsquo;m giving it one more chance, but I haven&rsquo;t found the right use case yet. For me it feels like a more civilized version of OpenClaw, which was very popular a few months ago, but maybe I need more time to figure it out.</p>
<p>One thing I like so far is the concept of profiles - I can create a few of them: a professional one for development, a home one for my &ldquo;normal&rdquo; things, one for home management, maybe a gamer profile if I find something specific to games.</p>
<h3 id="pi">Pi</h3>
<p>I also tested <a href="https://pi.dev/">Pi</a> to see a different approach to working with agents and different workflows. This one is a minimal agent harness - you use it as an interface over Claude, Codex and other models. It&rsquo;s very minimal, but it can be extended a lot. I haven&rsquo;t found the exact use for it in my workflow yet, as it seems that I prefer more complex solutions, but perhaps I&rsquo;m going to find something soon.</p>
<p>The one big minus I found so far: it doesn&rsquo;t play well with Claude Code on a subscription plan.</p>
<h3 id="t3-code">T3 Code</h3>
<p>IMHO <a href="https://t3.codes/">T3 Code</a> sits somewhere between Orca and Herdr in my flow. It seems to be very powerful and configurable, but at the same time it doesn&rsquo;t push tons of features in front of your face in the first interaction. It has a nice chat-like experience and a friendly feeling.</p>
<h2 id="my-own-harness">My own harness</h2>
<p>Tools are one half of the story. If I want to hand work over to an agent, it needs a proper harness: rules and tools it can use without asking me about every little thing. I think now is a good moment to build my own small CLIs to support that for any project that takes more than one prompt.</p>
<p>For a project <code>foo</code> I&rsquo;d create a <code>foo</code> CLI that becomes the entry point for interacting with the app from the terminal, for both me and the agent.</p>
<p>Since I prepared a CLI like this in my main projects, I&rsquo;ve noticed that I interact with agents much better and get a faster feedback loop. That can matter a lot when many changes start coming in.</p>
<h3 id="isolated-environments">Isolated environments</h3>
<p>The CLI should be able to start independent contexts. Each one gets its own git worktree, its own ports and, if needed, its own database. This way agents (and me!) can build and test different things in parallel without stepping on each other&rsquo;s toes.</p>
<p>The basic commands:</p>
<ul>
<li><code>up</code> - create or start a context with everything it needs,</li>
<li><code>list</code> - show what&rsquo;s running, so I know what&rsquo;s open,</li>
<li><code>down</code> / <code>remove</code> - stop or delete an environment and clean up after it.</li>
</ul>
<h3 id="logging-in-to-a-specific-app-state">Logging in to a specific app state</h3>
<p>A <code>login</code> command should log in to a given context as a chosen user, with a specific role and feature flags. An agent needs it for E2E tests, and I need it to check the changes and give feedback for the next iteration. Not everything can be delegated without me!</p>
<h3 id="screenshots-as-proof-of-work">Screenshots as proof of work</h3>
<p>Another useful command, <code>shot</code>, takes a screenshot of a given URL in a given version of the app. The agent starts the environment, logs in and takes a screenshot to show me what it did. Add some app-specific skills on top of that, and you have a solid base for more automation.</p>
<h3 id="try-it-yourself">Try it yourself</h3>
<p>If you want to experiment with this in your own project, here&rsquo;s a starter prompt. Treat it as a base and tweak it to your setup:</p>



<details class="collapsable-code" open>
    <summary title="Click to interact"><span class="collapsable-code__title">Starter prompt</span></summary>
    <div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;"><code class="language-plain" data-lang="plain"><span style="display:flex;"><span>I want to create a small CLI called `&lt;project&gt;` that will be the entry point
</span></span><span style="display:flex;"><span>for working with this project from the terminal, for both me and agents.
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>First, explore the repo and tell me how the app is started, what it needs
</span></span><span style="display:flex;"><span>(ports, database, env variables, seed data) and how tests are run. Don&#39;t write
</span></span><span style="display:flex;"><span>any code yet - propose a plan and wait for my approval.
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Then implement these commands:
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>- `up` - create or start an isolated context: its own git worktree, its own
</span></span><span style="display:flex;"><span>  ports and, if needed, its own database
</span></span><span style="display:flex;"><span>- `list` - show which contexts are running
</span></span><span style="display:flex;"><span>- `down` - stop a context and clean up after it
</span></span><span style="display:flex;"><span>- `login` - log in to a context as a chosen user, with a given role and
</span></span><span style="display:flex;"><span>  feature flags
</span></span><span style="display:flex;"><span>- `shot` - take a screenshot of a given URL in a given context (start it and
</span></span><span style="display:flex;"><span>  log in first if needed)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>Keep it small and readable, use the tools this project already uses, and add a
</span></span><span style="display:flex;"><span>short section to the README and a note for agents (AGENTS.md or a skill) on how
</span></span><span style="display:flex;"><span>to use the CLI.</span></span></code></pre></div></details>

<h3 id="shared-or-just-mine">Shared or just mine?</h3>
<p>One more thing that keeps my mind busy: I still don&rsquo;t really know how much of this should be shared with the team and how much should stay my own. The commands I described seem like a good common base. But the deeper we go, the more new commands and variants will depend on the setup each of us works in.</p>
<p>I think this is a great moment to talk about it with teammates (if you have them). A few of those conversations really sparked my interest in the topic and made me tweak my own approach.</p>
<h2 id="many-repos-one-home">Many repos, one home</h2>
<p>What if a project is split into several repositories? Instead of going monorepo, you can create a parent &ldquo;home repo&rdquo;. It holds the CLI and a description of the structure for the agent: where the API, UI and mobile app repos live and how to run them together.</p>
<p>I start the agent from that directory. It has one place to coordinate everything and knows where to look for each part, even though they live in separate repos.</p>
<p>Matt Pocock wrote about it really nicely in <a href="https://www.aihero.dev/the-home-repo-pattern">The Home Repo Pattern</a>, so if you want to dig deeper, start there.</p>
<h2 id="so-what">So what?</h2>
<p>If the tooling is done right - isolated environments, logging in, running things and showing proof - agents can work much more on their own. And I can focus on what I actually want to do: defining tasks, checking the results and moving on to the next iteration, instead of babysitting the basics.</p>
<p>Let&rsquo;s see how it looks in a few months. I bet half of these tools will change by then! 😅</p>
<hr>
]]></description>
    </item>
    
  </channel>
</rss>
