<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="/feed.xsl"?>
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Chris Wijnia — Notes</title>
    <link>https://chriswijnia.com/</link>
    <atom:link href="https://chriswijnia.com/feed.xml" rel="self" type="application/rss+xml" />
    <description>Things I’m working on, learning or trying to understand.</description>
    <language>en</language>
    <item>
      <title>A notes site that looks like my terminal</title>
      <link>https://chriswijnia.com/notes/a-notes-site-that-looks-like-my-terminal</link>
      <guid isPermaLink="true">https://chriswijnia.com/notes/a-notes-site-that-looks-like-my-terminal</guid>
      <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
      <category>Experiments</category>
      <description>A notes site drawn as a terminal draws Markdown, because that is the screen I look at all day, and because agents read the same file.</description>
      <content:encoded><![CDATA[<p>Most of my day is a terminal. Coding agents run in panes beside each other, every one of them a text interface, all in one mono font. So when I gave my notes their own address, <a href="https://cwdx.md" target="_blank" rel="noopener">cwdx.md</a>, I made it look like that screen instead of like a blog.</p>
<p>The address is half the joke. <code>cwdx</code> is my handle on GitHub, and <code>.md</code>, Moldova’s country code, is also the extension every Markdown file ends in. A notes site written in Markdown could hardly ask for a better name.</p>
<p>It is an experiment, with two ideas behind it. Markdown is the point: what you read there is the file, coloured, not a page made from it. And agents read the same file people do.</p>
<h2 id="the-screen-it-copies" data-no="01 / 04" data-hud="01 The screen it copies">The screen it copies</h2>
<p>This is roughly what I look at, redrawn with made-up agents: the sessions on the left, the one I’m talking to in the middle, a live panel on the right.</p>
<figure class="screen not-prose" role="img" aria-label="Terminal screen: my workspace, redrawn"><figcaption class="screen__bar bg-ink mono-label">my workspace, redrawn</figcaption><pre><span class="ansi-90">┌────────────┬──────────────────────────┬─────────────┐</span>
<span class="ansi-90">│</span><span class="ansi-90"> agents</span>     <span class="ansi-90">│</span> <span class="ansi-33">notes</span><span class="ansi-90"> ─ claude</span>           <span class="ansi-90">│</span><span class="ansi-90"> status</span>      <span class="ansi-90">│</span>
<span class="ansi-90">│</span><span class="ansi-32"> <span class="screen__odd">●</span></span> lead     <span class="ansi-90">│</span>                          <span class="ansi-90">│</span> build <span class="ansi-32"><span class="screen__odd">✓</span></span>     <span class="ansi-90">│</span>
<span class="ansi-90">│</span><span class="ansi-90">   done</span>     <span class="ansi-90">│</span> <span class="screen__odd">●</span> Shipped. Both sites    <span class="ansi-90">│</span> tests <span class="ansi-32"><span class="screen__odd">✓</span></span>     <span class="ansi-90">│</span>
<span class="ansi-90">│</span><span class="ansi-33"> <span class="screen__odd">●</span></span> site     <span class="ansi-90">│</span>   are live.              <span class="ansi-90">│</span> deploy <span class="ansi-33">…</span>    <span class="ansi-90">│</span>
<span class="ansi-90">│</span><span class="ansi-90">   working</span>  <span class="ansi-90">│</span>                          <span class="ansi-90">│</span>             <span class="ansi-90">│</span>
<span class="ansi-90">│</span><span class="ansi-33"> <span class="screen__odd">●</span></span> docs     <span class="ansi-90">│</span><span class="ansi-90"> <span class="screen__odd">❯</span> </span>write the next note    <span class="ansi-90">│</span><span class="ansi-90"> 18:25</span>       <span class="ansi-90">│</span>
<span class="ansi-90">│</span><span class="ansi-90">   working</span>  <span class="ansi-90">│</span>                          <span class="ansi-90">│</span> <span class="ansi-36">▁▂▄▆▅▃▂▁</span>    <span class="ansi-90">│</span>
<span class="ansi-90">│</span><span class="ansi-90"> <span class="screen__odd">○</span></span> inbox    <span class="ansi-90">│</span><span class="ansi-90"> <span class="screen__odd">⏵</span><span class="screen__odd">⏵</span> auto mode on</span>          <span class="ansi-90">│</span>             <span class="ansi-90">│</span>
<span class="ansi-90">└────────────┴──────────────────────────┴─────────────┘</span></pre></figure>
<h2 id="drawn-the-way-glow-draws-it" data-no="02 / 04" data-hud="02 Drawn the way glow draws it">Drawn the way glow draws it</h2>
<p><a href="https://github.com/charmbracelet/glow" target="_blank" rel="noopener">glow</a> is a tool that shows Markdown in a terminal. cwdx.md sets each note on a grid of character cells the way glow does, and a test holds its layout to glow’s own output at the same width. Headings keep their <code>##</code>, code keeps its colours, and a table is drawn with box lines.</p>
<p>The page itself is a canvas, so it can do what a terminal can’t:</p>
<ul>
<li><strong>A sea behind the text.</strong> A slow field of Markdown’s own marks moves around the column and ripples where you click.</li>
<li><strong>Real text underneath.</strong> Every word is laid over the drawing as invisible text, so it selects, copies, links and reads without JavaScript.</li>
<li><strong>Keys.</strong> Arrows move, enter opens, typing searches, <code>?</code> shows the rest. Seven themes cycle on <code>t</code>.</li>
<li><strong>Diagrams and screens.</strong> Mermaid is drawn in the grid’s colours, and a <code>screen</code> block like the one above shows a terminal as text, never an image.</li>
</ul>
<h2 id="agents-get-the-file" data-no="03 / 04" data-hud="03 Agents get the file">Agents get the file</h2>
<p>Ask for a note without a browser and cwdx.md answers with the Markdown, not HTML:</p>
<div class="code-win"><pre class="code" data-lang="sh"><code class="hljs">curl cwdx.md/a-notes-site-that-looks-like-my-terminal.md
</code></pre>
</div>
<p>The site also has an <code>llms.txt</code>, a sitemap and a feed, written from the same files. There is one source for people and machines, and nothing to keep in sync.</p>
<h2 id="open-questions" data-no="04 / 04" data-hud="04 Open questions">Open questions</h2>
<ul>
<li>A canvas page is harder to make accessible than plain HTML. The text layer helps, but is it enough for a screen reader?</li>
<li>Would a terminal-looking site still feel like home to someone who doesn’t live in one?</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>Working with agents by ear</title>
      <link>https://chriswijnia.com/notes/working-with-agents-by-ear</link>
      <guid isPermaLink="true">https://chriswijnia.com/notes/working-with-agents-by-ear</guid>
      <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
      <category>Experiments</category>
      <description>After eye surgery I couldn't look at a screen for long, so I steered my coding agents by voice. What made that usable, and the plugin that came out of it.</description>
      <content:encoded><![CDATA[<p>After eye surgery I couldn’t look at a screen for long, and the agents still needed steering. So I asked one to stop sending me tables and just talk. A few days later that had turned into a plugin for Claude Code. It’s called vox and it’s <a href="https://github.com/cwdx/vox" target="_blank" rel="noopener">open source</a>.</p>
<h2 id="three-things-made-it-usable" data-no="01 / 06" data-hud="01 Three things made it usable">Three things made it usable</h2>
<p>Claude Code has a voice mode, but you hold a key to talk, and that didn’t work in my terminal. Having the reply read aloud was the easy part. These made it something I could work with all day:</p>
<ul>
<li><strong>An open mic that sends by itself.</strong> I talk, I stop, the message goes. A pause in the middle of a thought waits a little longer than a pause after a full sentence.</li>
<li><strong>It knows my voice.</strong> An open mic hears everyone. Once the helper knew my voice, somebody else talking in the room no longer ended up in the session. It cancels echo too, so the agent doesn’t hear itself, and it stops talking the moment I start.</li>
<li><strong>Big letters.</strong> The last words sit above the prompt in block letters I can read at a glance.</li>
</ul>
<figure class="mermaid-embed not-prose"><figcaption class="mermaid-state mono-label">Diagram</figcaption><pre class="mermaid-src">flowchart TB
  M[&quot;Mic&lt;br/&gt;echo cancelled&quot;] --&gt; H[&quot;Helper&lt;br/&gt;types the words as I talk&quot;]
  H --&gt; V{&quot;My voice?&quot;}
  V --&gt;|no| X[&quot;Dropped&quot;]
  V --&gt;|yes| P[&quot;A pause&lt;br/&gt;shorter after a full sentence&quot;]
  P --&gt; F[&quot;A second model&lt;br/&gt;reads the message again&quot;]
  F --&gt; S[&quot;Sent to the agent&quot;]:::lit
  S --&gt; R[&quot;The reply&lt;br/&gt;spoken as it streams&quot;]
</pre></figure>
<h2 id="a-fox-instead-of-a-status-bar" data-no="02 / 06" data-hud="02 A fox instead of a status bar">A fox instead of a status bar</h2>
<p>One line above the prompt holds everything: a fox whose face is the state, the two switches, the mic as an equalizer and the words so far. Here it is in five states.</p>
<figure class="screen not-prose" role="img" aria-label="Terminal screen: vox"><figcaption class="screen__bar bg-ink mono-label">vox</figcaption><pre><span class="ansi-36">^•<span class="screen__odd">ᴗ</span>•^ listening</span>    <span class="ansi-90">mic</span> <span class="ansi-32"><span class="screen__odd">●</span></span>  <span class="ansi-90">voice</span> <span class="ansi-32"><span class="screen__odd">●</span></span>  <span class="ansi-36">▁▁▁▁▁▁▁▁▁▁</span>
<span class="ansi-96">^°<span class="screen__odd">ᴗ</span>°^ hearing you</span>  <span class="ansi-90">mic</span> <span class="ansi-32"><span class="screen__odd">●</span></span>  <span class="ansi-90">voice</span> <span class="ansi-32"><span class="screen__odd">●</span></span>  <span class="ansi-36">▃▅</span><span class="ansi-33">▇▆</span><span class="ansi-36">▄</span><span class="ansi-33">▆▇▆</span><span class="ansi-36">▄▂</span>  “run the tests and”
<span class="ansi-33">^•_•^ working</span>      <span class="ansi-90">mic</span> <span class="ansi-32"><span class="screen__odd">●</span></span>  <span class="ansi-90">voice</span> <span class="ansi-32"><span class="screen__odd">●</span></span>  <span class="ansi-36">▁▁▁▁▁▁▁▁▁▁</span>
<span class="ansi-95">^•o•^ talking</span>      <span class="ansi-90">mic</span> <span class="ansi-32"><span class="screen__odd">●</span></span>  <span class="ansi-90">voice</span> <span class="ansi-32"><span class="screen__odd">●</span></span>  <span class="ansi-35">▄</span><span class="ansi-34">▆</span><span class="ansi-35">▅</span><span class="ansi-34">▇</span><span class="ansi-35">▅</span><span class="ansi-34">▇</span><span class="ansi-35">▄▃</span><span class="ansi-34">▆</span><span class="ansi-35">▄</span>
<span class="ansi-90">^¬_¬^ not you</span>      <span class="ansi-90">mic</span> <span class="ansi-32"><span class="screen__odd">●</span></span>  <span class="ansi-90">voice</span> <span class="ansi-32"><span class="screen__odd">●</span></span>  <span class="ansi-36">▃▄▃▂▁▁▁▁▁▁</span></pre></figure>
<p>Clicking the fox opens the full view, where the last words stand five rows tall under a larger equalizer.</p>
<figure class="screen not-prose" role="img" aria-label="Terminal screen: vox, full view"><figcaption class="screen__bar bg-ink mono-label">vox, full view</figcaption><pre><span class="ansi-33">   ▁▁ ▅▅ ▇▇ ▅▅ ▂▂ ▄▄ ▇▇ ▆▆ ▂▂ ▁▁ ▄▄ ▆▆ ▃▃</span>
<span class="ansi-36">▆▆ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██</span>

<span class="ansi-96">██  █ █ █  █  ███ █ █ ███  ███ ███  ██ ███  ██</span>
<span class="ansi-96">█ █ █ █ ██ █   █  █ █ █     █  █   █    █  █</span>
<span class="ansi-96">██  █ █ █ ██   █  ███ ██    █  ██   █   █   █</span>
<span class="ansi-96">█ █ █ █ █  █   █  █ █ █     █  █     █  █    █</span>
<span class="ansi-96">█ █ ███ █  █   █  █ █ ███   █  ███ ██   █  ██</span></pre></figure>
<h2 id="the-agent-had-to-learn-to-talk" data-no="03 / 06" data-hud="03 The agent had to learn to talk">The agent had to learn to talk</h2>
<p>A reply written for the screen is useless by ear. Nobody wants a table read out. So the plugin ships a writing style for the agent:</p>
<ul>
<li><strong>Answer first.</strong> The first sentence has to make sense on its own, because the listener may stop there.</li>
<li><strong>One or two short sentences.</strong> No lists and no headings, since speech flattens them.</li>
<li><strong>Choices by number.</strong> Options are read out as one, two, three, and I answer with one key.</li>
</ul>
<p>It forgot, of course. On the first day it answered with a list and I had to remind it of its own rules. Now the plugin loads them again every 25 prompts.</p>
<h2 id="what-it-gets-wrong" data-no="04 / 06" data-hud="04 What it gets wrong">What it gets wrong</h2>
<p>Dictation mishears names. My terminal is called herdr, and it came out as “her” and “herder”. “Wait mode” became “weight mode”. A small dictionary fixes the words I use most, and a second speech model reads every message again before it’s sent, in about 0.06 seconds on an M2.</p>
<p>Speech recognition runs on the machine, and no audio leaves it.</p>
<h2 id="try-it" data-no="05 / 06" data-hud="05 Try it">Try it</h2>
<div class="code-win"><pre class="code" data-lang=""><code class="hljs">/plugin marketplace add cwdx/vox
/plugin install vox@vox
/vox setup
</code></pre>
</div>
<table>
<thead>
<tr>
<th></th>
<th>macOS</th>
<th>Linux</th>
</tr>
</thead>
<tbody>
<tr>
<td>Speech</td>
<td><code>say</code></td>
<td>piper or espeak-ng</td>
</tr>
<tr>
<td>Dictation</td>
<td>Swift, echo cancelled</td>
<td>Python</td>
</tr>
<tr>
<td>Only my voice</td>
<td>yes</td>
<td>not yet</td>
</tr>
</tbody>
</table>
<p>Dictation types into <a href="https://herdr.dev" target="_blank" rel="noopener">herdr</a> panes, so it needs herdr. Much of vox was built by asking for it out loud, which is a decent test of a voice tool.</p>
<h2 id="open-questions" data-no="06 / 06" data-hud="06 Open questions">Open questions</h2>
<ul>
<li>How do you review code by ear? Short glances at the screen were still part of it.</li>
<li>Recognising one voice only works on macOS so far. What does it take on Linux?</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>One person, many agents, and a phone</title>
      <link>https://chriswijnia.com/notes/one-person-many-agents</link>
      <guid isPermaLink="true">https://chriswijnia.com/notes/one-person-many-agents</guid>
      <pubDate>Thu, 01 Oct 2026 00:00:00 GMT</pubDate>
      <category>Systems</category>
      <description>How I run many coding agents across a Mac and a rented Linux box from my phone, and the parts you need to build the same.</description>
      <content:encoded><![CDATA[<p>Agents write most of my code now. Most of my day goes on deciding which of them get to keep going, and I need to do that from anywhere, a phone included, without any agent reaching something it shouldn’t. Here is how the setup works and what it is built from, if you want the same.</p>
<h2 id="two-machines-one-private-network" data-no="01 / 06" data-hud="01 Two machines, one private network">Two machines, one private network</h2>
<p>Anything that needs a secret stays on the Mac, along with the dev servers and the browser for UI work. A rented Linux server does the rest. It’s a 16-core box on a one-week trial that cost a few euros. It runs headless builders that need no credentials, and it has its own logins, so nothing gets copied over from the Mac.</p>
<p>Both machines sit on a private Tailscale network. The server’s firewall drops all public traffic, so only the tailnet can reach it. Two small pages are served to the tailnet and nowhere else, a report page and the agent board.</p>
<figure class="mermaid-embed not-prose"><figcaption class="mermaid-state mono-label">Diagram</figcaption><pre class="mermaid-src">flowchart TB
  P[&quot;Phone&lt;br/&gt;Moshi · RustDesk · browser&quot;] --&gt; T((&quot;Tailscale&lt;br/&gt;private&quot;))
  T --&gt; MAC
  T --&gt; LIN
  subgraph MAC[&quot;Mac · holds the secrets&quot;]
    I[&quot;Steward&quot;] --&gt; S[&quot;Lead&quot;]
    B1[&quot;Builders&quot;]
    V[&quot;Dev servers&lt;br/&gt;board · reports&quot;]
    S ~~~ B1 ~~~ V
  end
  subgraph LIN[&quot;Linux worker · no secrets&quot;]
    B2[&quot;Headless builders&quot;]
    L2[&quot;Its own logins&lt;br/&gt;Claude · GitHub&quot;]
    B2 ~~~ L2
  end
  MAC --&gt; G[&quot;GitHub&lt;br/&gt;cards · checks · reviews&quot;]
  LIN --&gt; G
  G --&gt; Q{&quot;One gate&quot;}:::lit
  Q --&gt;|proven| D[&quot;Dev branch&quot;]
  Q --&gt;|needs me| O[&quot;Me&quot;]
</pre></figure>
<h2 id="one-session-orchestrates" data-no="02 / 06" data-hud="02 One session orchestrates">One session orchestrates</h2>
<p>Every agent is a Claude Code session in herdr. herdr is a terminal multiplexer, and it shows whether each session is working, idle, done or blocked, on either machine.</p>
<p>One long-running session never writes product code. It’s the lead, and everything goes through it. It reads the board, starts builders, passes decisions along, merges what is proven and writes a hand-off note for when I come back. A second session, the steward, gathers what needs my attention and reports it to the lead, so it reaches me from one place.</p>
<h2 id="github-is-the-feedback-loop" data-no="03 / 06" data-hud="03 GitHub is the feedback loop">GitHub is the feedback loop</h2>
<p>Most of the job is triage. Issues become cards on a GitHub Project with five columns. A card is ready only when it says what done means and how to prove it. A builder claims a card with a lease, works in its own git worktree and opens a pull request.</p>
<p>After that, the builder answers to the checks. It reads CI, tests, linters and review comments, from people and from review bots, and responds before anyone looks. Only work that clears a strict gate merges on its own. Anything that touches production or money comes to me, and so does any action an agent was refused. No other agent retries a refused action.</p>
<h2 id="a-skill-builds-the-workstation" data-no="04 / 06" data-hud="04 A skill builds the workstation">A skill builds the workstation</h2>
<p>I never set up the workstation by hand. One skill installs everything on it: Ghostty and herdr, Hunk for diffs, Lazygit, Neovim, Raycast, Nerd Fonts, Tailscale and Moshi. A second skill sets herdr to a baseline. When I change something live, the change goes into the skill too, so running it again rebuilds the same machine. The setup looks like this site, with Departure Mono on an amber theme. Amber marks one thing only, an agent’s state.</p>
<h2 id="build-your-own" data-no="05 / 06" data-hud="05 Build your own">Build your own</h2>
<ol>
<li>Put the machines on a tailnet and close everything else: <a href="https://tailscale.com/kb/1193/tailscale-ssh" target="_blank" rel="noopener">Tailscale SSH</a> and <a href="https://tailscale.com/kb/1312/serve" target="_blank" rel="noopener">Tailscale Serve</a> for pages only you can open. Decide early how agents sign in over SSH, because check mode makes every new session wait for your approval.</li>
<li>Rent a worker by the week (<a href="https://www.hetzner.com/cloud" target="_blank" rel="noopener">Hetzner Cloud</a>) and give it its own logins rather than your secrets.</li>
<li>Run agents in <a href="https://code.claude.com/docs" target="_blank" rel="noopener">Claude Code</a> inside <a href="https://herdr.dev" target="_blank" rel="noopener">herdr</a>, one <a href="https://git-scm.com/docs/git-worktree" target="_blank" rel="noopener">git worktree</a> each.</li>
<li>Make the board the source of truth: <a href="https://docs.github.com/en/issues/planning-and-tracking-with-projects" target="_blank" rel="noopener">GitHub Projects</a>, driven with the <a href="https://cli.github.com" target="_blank" rel="noopener">GitHub CLI</a>, and merges held to <a href="https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/collaborating-on-repositories-with-code-quality-features/about-status-checks" target="_blank" rel="noopener">required status checks</a>.</li>
<li>Steer from the phone with <a href="https://getmoshi.app" target="_blank" rel="noopener">Moshi</a> for terminals and <a href="https://rustdesk.com" target="_blank" rel="noopener">RustDesk</a> in direct IP mode for the desktop.</li>
</ol>
<h2 id="open-questions" data-no="06 / 06" data-hud="06 Open questions">Open questions</h2>
<ul>
<li>How many agents can one person review before the review becomes the bottleneck?</li>
<li>Which decisions can safely move from “ask me” to the gate, and how would I know when one shouldn’t have?</li>
<li>Is a second remote worker worth it, or does it just move the waiting somewhere else?</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>Developer tools for normal teams</title>
      <link>https://chriswijnia.com/notes/developer-tools-for-normal-teams</link>
      <guid isPermaLink="true">https://chriswijnia.com/notes/developer-tools-for-normal-teams</guid>
      <pubDate>Thu, 24 Sep 2026 00:00:00 GMT</pubDate>
      <category>AI</category>
      <description>Every team using AI is about to hit problems software teams solved years ago. The fix is the same four tools under other names.</description>
      <content:encoded><![CDATA[<p>Every team that uses AI seriously runs into the same wall, and it isn’t the price of tokens. Once several agents are doing real work, nobody can say for certain what they did or whether it was right.</p>
<p>Software teams have had that problem for decades, with people instead of agents, and they solved it with a handful of tools. I think those tools are about to leave engineering. This is the argument I made at an AI meetup. The slides are at the end.</p>
<h2 id="the-wall-is-trust" data-no="01 / 09" data-hud="01 The wall is trust">The wall is trust</h2>
<p>Starting an agent is easy. Anyone can point one at an inbox or a spreadsheet in an afternoon.</p>
<p>The hard part comes afterwards. An agent rarely fails loudly. It summarises a little less carefully, skips a field in the CRM, drafts a proposal that is nearly right. If nothing checks the work and nothing records it, you find out weeks later, from a customer.</p>
<p>So the first question I’d ask about any agent is “how would I know?”</p>
<h2 id="how-a-small-team-runs-millions-of-lines" data-no="02 / 09" data-hud="02 How a small team runs millions of lines">How a small team runs millions of lines</h2>
<p>The codebase I work in every day runs to millions of lines across dozens of apps and services, and a small team maintains it. No one person holds all of it in their head.</p>
<p>It works because the agents that do much of the work operate inside a few rules we wrote down, and because nothing they produce lands without being checked. The rules are written playbooks, which we call skills. The work is split between specialised agents for planning, coding, reviewing and shipping. None of that is exotic. It’s mostly the standard toolkit of any well-run engineering team, applied to agents instead of people.</p>
<h2 id="four-tools-under-other-names" data-no="03 / 09" data-hud="03 Four tools under other names">Four tools under other names</h2>
<p>Each of these exists in software because many hands working in one system break things in ways nobody notices until later. Agents are many hands.</p>
<ul>
<li><strong>Checks the agent can run itself.</strong> Developers have tests: code that fails when something breaks. For everyone else it’s a checklist, a sample to compare against, or a number that has to move. An agent that can check its own work improves without you. One that can’t makes you the test.</li>
<li><strong>A record of everything.</strong> Developers have version history: every change, who made it, and a way back. For everyone else it’s Linear, Drive or Notion, as long as the agent writes where people already read.</li>
<li><strong>Know-how written down once.</strong> Developers have runbooks. For agents, the same idea is a skill: a short instruction loaded when the task needs it. The useful ones come from watching an agent fail at the same thing twice.</li>
<li><strong>Gates sized to the mistake.</strong> Developers have code review. For everyone else it’s approval: light for a draft email, heavier for a payment or a contract.</li>
</ul>
<figure class="mermaid-embed not-prose"><figcaption class="mermaid-state mono-label">Diagram</figcaption><pre class="mermaid-src">flowchart LR
  D1[&quot;Tests&quot;] --&gt; E1[&quot;A checklist, a sample&lt;br/&gt;or a number that moves&quot;]
  D2[&quot;Version history&quot;] --&gt; E2[&quot;Linear, Drive or Notion&quot;]
  D3[&quot;Runbooks&quot;] --&gt; E3[&quot;A skill&quot;]
  D4[&quot;Code review&quot;] --&gt; E4[&quot;Approval sized&lt;br/&gt;to the mistake&quot;]:::lit
</pre></figure>
<p>A team can pick up all four habits without hiring a developer.</p>
<h2 id="keeping-track-is-the-one-to-start-with" data-no="04 / 09" data-hud="04 Keeping track is the one to start with">Keeping track is the one to start with</h2>
<p>If I had to pick one, it’s the record. Every agent, whatever it does, writes to the same place: what it did, and whether its check passed.</p>
<p>That’s also how you catch the quiet failure. A shared log turns “the agent seems fine” into something you can see. Work that isn’t tracked can’t be checked later, so nobody can tell whether it went wrong.</p>
<h2 id="each-step-needs-a-new-guardrail" data-no="05 / 09" data-hud="05 Each step needs a new guardrail">Each step needs a new guardrail</h2>
<p>Boris Cherny, who built Claude Code, <a href="https://x.com/bcherny/status/2077929379661844559" target="_blank" rel="noopener">describes five steps of AI adoption</a>: gated, then assisted (about one agent per person), parallel (about ten), supervised autonomy (about a hundred), and AI-native (a thousand or more). His point, which matches what I’ve seen, is that tokens alone don’t move a team up a step. Removing the next bottleneck and building the next guardrail does.</p>
<p>The four tools above are those guardrails. Most teams outside engineering are on the first or second step, and the jump to the third is where they start to matter. At ten agents per person, nobody can supervise every output by eye.</p>
<h2 id="one-install-for-the-whole-team" data-no="06 / 09" data-hud="06 One install for the whole team">One install for the whole team</h2>
<p>Habits spread badly by memo. What worked for us was packaging them. The team gets one plugin for Claude Cowork, installed once, with no terminal involved. It holds the skills, the connections to our own systems and the checks:</p>
<ul>
<li><strong>Skills.</strong> For example, an inbox assistant that learns your tone from your sent mail and drafts replies on a schedule.</li>
<li><strong>Connectors.</strong> Links to the company’s docs, CRM and data, so a question in plain words gets an answer from the real source.</li>
<li><strong>Checks.</strong> For example, a fact-checker that re-derives every claim in a draft before it goes out.</li>
</ul>
<p>The plugin is built from what we actually run, so when someone adds a skill or a connection, everyone has it on the next update. Nobody maintains a separate list, so there is no list to go stale.</p>
<h2 id="can-normal-teams-run-this" data-no="07 / 09" data-hud="07 Can normal teams run this?">Can normal teams run this?</h2>
<p>The meetup asked. Yes. None of the four tools requires writing code, and a plugin installs them for everyone at once. Agents break things quietly when there’s no check and no record. With both, a problem shows up in the log the same day.</p>
<h2 id="the-slides" data-no="08 / 09" data-hud="08 The slides">The slides</h2>
<div class="deck-embed not-prose" data-deck="developer-tools-for-normal-teams"><p class="mono-label"><a href="/decks/developer-tools-for-normal-teams">Open the deck ►</a></p></div>
<h2 id="open-questions" data-no="09 / 09" data-hud="09 Open questions">Open questions</h2>
<ul>
<li>How small can the record be before it stops being useful? A spreadsheet works for one team; I don’t know where it stops working.</li>
<li>Who writes the skills in a team with no engineers, and who decides when one is wrong?</li>
<li>Checks are easy for numbers and hard for judgement. What’s the checklist for “is this a good proposal”?</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>Jev, tiny models and strange new interfaces</title>
      <link>https://chriswijnia.com/notes/jev-tiny-models-strange-interfaces</link>
      <guid isPermaLink="true">https://chriswijnia.com/notes/jev-tiny-models-strange-interfaces</guid>
      <pubDate>Wed, 23 Sep 2026 00:00:00 GMT</pubDate>
      <category>Experiments</category>
      <description>Small, fast models that pick one option from a fixed set don’t chat. They decide, and that invites interfaces that don’t look like chat at all.</description>
      <content:encoded><![CDATA[<p>Most of what people call AI today looks like a conversation. You type, it types back. That shape made sense for the first generation of large models, but it isn’t the only one, and it may not be the most useful.</p>
<h2 id="a-different-kind-of-model" data-no="01 / 05" data-hud="01 A different kind of model">A different kind of model</h2>
<p>Jev, from TypeSafe, is a good example of another shape. You give it structured state and a fixed set of options, and it returns one choice with a confidence attached. It writes no prose and holds no conversation.</p>
<p>That limit is what makes it useful. A model that can only choose from valid options can’t hallucinate an invalid one. Its answer is typed, so the software around it can trust the format and act on it immediately.</p>
<figure class="mermaid-embed not-prose"><figcaption class="mermaid-state mono-label">Diagram</figcaption><pre class="mermaid-src">flowchart TB
  S[&quot;Structured state&quot;] --&gt; J((&quot;Jev&quot;))
  O[&quot;A fixed set of options&quot;] --&gt; J
  J --&gt; C[&quot;One choice&lt;br/&gt;with a confidence&quot;]:::lit
  C --&gt; X[&quot;The software acts on it&quot;]
</pre></figure>
<h2 id="why-small-matters" data-no="02 / 05" data-hud="02 Why small matters">Why small matters</h2>
<p>When a model only has to decide, it can be small and fast, and that changes what you can build with it. You can ask for many small choices a second, where a large model gives one long answer. It is cheap enough to call on every step and not only the important ones. The set of possible outputs is known in advance, so its behaviour can be tested.</p>
<p>It’s closer to a game engine’s logic than to a chatbot.</p>
<h2 id="interfaces-without-chat" data-no="03 / 05" data-hud="03 Interfaces without chat">Interfaces without chat</h2>
<p>If the model decides instead of talks, the interface doesn’t need a text box. It can be a character moving through a world, a system choosing its next step, or an old piece of software driven by something that has never seen a keyboard.</p>
<p>Those experiments look strange next to today’s assistants, and that’s why I like them. Every new kind of model has made new interfaces possible, and the first ones always look like toys.</p>
<h2 id="two-to-try" data-no="04 / 05" data-hud="04 Two to try">Two to try</h2>
<p>I built two of those strange interfaces on this site, as <a href="/lab">experiments</a>.</p>
<ul>
<li><strong><a href="/lab/chess">Chess with Jev</a>.</strong> Code works out every legal move’s facts: exchanges, mates, threats. Jev picks one move from that list each turn and shows how sure it is. Play it, or watch it play itself.</li>
<li><strong><a href="/lab/emoji">1 Million Emojis</a>.</strong> A shared canvas of a million emoji cells, live for everyone. After each stroke you paint, Jev chooses a square next to it and what goes there.</li>
</ul>
<h2 id="open-questions" data-no="05 / 05" data-hud="05 Open questions">Open questions</h2>
<ul>
<li>Which everyday software is really a long series of small, typed decisions?</li>
<li>How do you show someone what a decision-making model is doing, without a transcript to read?</li>
<li>When does a choice from a fixed set stop being enough?</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>What finance looks like when software becomes an actor</title>
      <link>https://chriswijnia.com/notes/when-software-becomes-an-actor</link>
      <guid isPermaLink="true">https://chriswijnia.com/notes/when-software-becomes-an-actor</guid>
      <pubDate>Wed, 23 Sep 2026 00:00:00 GMT</pubDate>
      <category>Finance</category>
      <description>When software can act on money, not just record it, the hard questions stop being technical and become about permission and accountability.</description>
      <content:encoded><![CDATA[<p>For most of its history, financial software has been a ledger with a user interface. It records what people decided. Someone approves the payment, someone places the trade, and the software keeps track.</p>
<p>Software can now propose, decide and act. It can move funds when conditions are met, rebalance a portfolio, or respond to a request at three in the morning. Checking that the numbers are right is no longer enough. You also have to know who, or what, was allowed to act.</p>
<h2 id="from-records-to-decisions" data-no="01 / 04" data-hud="01 From records to decisions">From records to decisions</h2>
<p>Payment rails with APIs made the first step possible. Software can move money directly, under rules written next to it instead of in a separate process. Models add the second step, software that can read a situation and choose an action within those rules.</p>
<p>Put the two together and you get an actor. It is more than a tool and less than a person, and it holds permissions and uses them.</p>
<h2 id="designing-the-permissions" data-no="02 / 04" data-hud="02 Designing the permissions">Designing the permissions</h2>
<p>When software acts, the interesting design problem is the permission model:</p>
<ul>
<li><strong>Scope.</strong> What exactly may it do, with how much, and for how long?</li>
<li><strong>Limits.</strong> Hard caps that no instruction can override, enforced where the money lives, not in the prompt.</li>
<li><strong>Approval.</strong> Which actions need a human, and how that human sees enough context to say yes quickly and safely.</li>
<li><strong>Undo.</strong> Money often can’t be pulled back, so the checks have to happen before the action, not after.</li>
</ul>
<figure class="mermaid-embed not-prose"><figcaption class="mermaid-state mono-label">Diagram</figcaption><pre class="mermaid-src">flowchart TB
  R[&quot;Payment rails with APIs&lt;br/&gt;money software can move&quot;] --&gt; A((&quot;An actor&quot;))
  M[&quot;Models&lt;br/&gt;read a situation, choose an action&quot;] --&gt; A
  A --&gt; S[&quot;Scope&lt;br/&gt;what, how much, how long&quot;]
  S --&gt; L[&quot;Limits&lt;br/&gt;hard caps where the money lives&quot;]
  L --&gt; Q{&quot;Needs a human?&quot;}:::lit
  Q --&gt;|no| X[&quot;Act&quot;]
  Q --&gt;|yes| H[&quot;A person, with enough context&quot;] --&gt; X
</pre></figure>
<p>Good financial infrastructure already treats people this way. Delegated access, spending limits and multi-party approval are old ideas. The new part is applying them to something that acts at machine speed and never gets tired.</p>
<h2 id="accountability-stays-with-a-person" data-no="03 / 04" data-hud="03 Accountability stays with a person">Accountability stays with a person</h2>
<p>Regulation doesn’t care whether a person or a program made the call. Someone is still responsible. That’s healthy, because it forces a clear line between what the software proposes and what an accountable party authorises.</p>
<p>The systems that work will make that line visible. Every action traces to a permission, every permission traces to a person, and the log can go to an auditor without being rewritten first.</p>
<h2 id="open-questions" data-no="04 / 04" data-hud="04 Open questions">Open questions</h2>
<ul>
<li>How much autonomy will customers actually want over their own money, once it’s on offer?</li>
<li>What does a useful audit trail look like for a decision made by a model?</li>
<li>Where should limits live: in the model, the application, or the asset itself?</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>AI makes software cheaper. Systems thinking becomes more valuable.</title>
      <link>https://chriswijnia.com/notes/ai-makes-software-cheaper</link>
      <guid isPermaLink="true">https://chriswijnia.com/notes/ai-makes-software-cheaper</guid>
      <pubDate>Wed, 23 Sep 2026 00:00:00 GMT</pubDate>
      <category>Software</category>
      <description>Models make code cheap to write. They don’t make systems cheap to own, and that gap is where the valuable work moves.</description>
      <content:encoded><![CDATA[<p>Writing code is getting cheap fast. A function that took an afternoon now takes a prompt and a review. A prototype that took a week can exist by lunch.</p>
<p>It’s tempting to conclude that software itself is getting cheap. I don’t think it is. One part of it is getting cheap, the part where a clear intention turns into working lines. Most of the cost was never there.</p>
<h2 id="code-was-never-the-bottleneck" data-no="01 / 04" data-hud="01 Code was never the bottleneck">Code was never the bottleneck</h2>
<p>Most of the cost of software comes after the first commit. Someone has to keep it running, change it without breaking something three layers away, explain it to the next person and decide what not to build. None of that got cheaper this year.</p>
<p>Cheap code makes it worse. When a feature costs little to produce, you get more features and more integrations, and somebody has to own every one of them.</p>
<h2 id="what-becomes-valuable" data-no="02 / 04" data-hud="02 What becomes valuable">What becomes valuable</h2>
<p>When output is cheap, judgement is scarce. In practice that looks like:</p>
<ul>
<li><strong>Knowing where the boundaries are.</strong> Which parts of a system should know about each other, and which never should. A model will happily wire everything to everything.</li>
<li><strong>Choosing what to leave out.</strong> Code that was never written needs no maintenance.</li>
<li><strong>Seeing second-order effects.</strong> A change to how money moves, or how data is stored, shows up in places nobody is watching.</li>
<li><strong>Writing things down.</strong> Models work better with clear constraints, and so do teams. Good specs used to be a courtesy. Now they multiply everyone’s output.</li>
</ul>
<p>None of these skills are new. The effort of typing used to hide them.</p>
<h2 id="the-work-changed" data-no="03 / 04" data-hud="03 The work changed">The work changed</h2>
<p>I spend less time producing code and more time deciding what the code should be, reviewing what was produced and designing the system it lands in. The job looks more like editing than writing.</p>
<p>That makes the reviewer the bottleneck, which is uncomfortable. A model can produce a thousand plausible lines in a minute, and plausible isn’t the same as correct. So I lean on tests, types and small steps I can undo. They make fast change safe.</p>
<h2 id="open-questions" data-no="04 / 04" data-hud="04 Open questions">Open questions</h2>
<ul>
<li>If juniors learn by writing the code a model now writes, where does the next generation of systems thinkers come from?</li>
<li>How much review is enough when the volume of changes keeps growing?</li>
<li>Which of today’s “best practices” were really workarounds for expensive code, and can quietly go?</li>
</ul>
]]></content:encoded>
    </item>
  </channel>
</rss>
