<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Nic Flemmer</title>
    <description>The latest articles on DEV Community by Nic Flemmer (@nicholasflemmer).</description>
    <link>https://dev.to/nicholasflemmer</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4168431%2F58974da3-69f5-4031-bca1-727e77ff3904.jpg</url>
      <title>DEV Community: Nic Flemmer</title>
      <link>https://dev.to/nicholasflemmer</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/nicholasflemmer"/>
    <language>en</language>
    <item>
      <title>Hiding something is not the same as stopping it</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Wed, 11 Nov 2026 14:02:25 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/hiding-something-is-not-the-same-as-stopping-it-4al8</link>
      <guid>https://dev.to/nicholasflemmer/hiding-something-is-not-the-same-as-stopping-it-4al8</guid>
      <description>&lt;p&gt;When you remove a project from Styx's sidebar, nothing is deleted. Your files stay where they are, and the tasks, chat history and targets are kept out of sight in case you add the folder again.&lt;/p&gt;

&lt;p&gt;The thing I didn't want to leave behind was access. A project that's gone from the sidebar can still have an agent running in it, or a grant open on a deploy target, and you'd have no screen left to notice either. So before the project goes, Styx stops its agents and closes every grant on its targets.&lt;/p&gt;

&lt;p&gt;It's the same idea as the rest of the grant lifetime. Left alone, a grant ends when its time is up, after an hour without use, or when the task ends, whichever comes first. Each of those is an event that already exists, so access never depends on someone remembering to switch it off.&lt;/p&gt;

&lt;p&gt;The lesson I keep applying: tie a permission to something that will end, such as a clock, a task or a project, instead of to a person's attention.&lt;/p&gt;

&lt;p&gt;When it doesn't apply: a grant you deliberately make persistent. That's on purpose, but it's the one kind you do have to go and look at.&lt;/p&gt;

&lt;p&gt;I'm building Styx, where this came from.&lt;/p&gt;

</description>
      <category>agents</category>
      <category>security</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>Where should a coding agent's git worktree live?</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Tue, 10 Nov 2026 14:03:34 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/where-should-a-coding-agents-git-worktree-live-1oe5</link>
      <guid>https://dev.to/nicholasflemmer/where-should-a-coding-agents-git-worktree-live-1oe5</guid>
      <description>&lt;p&gt;Giving each coding agent its own git worktree is the easiest way I know to stop agents trampling each other, and you. The part I keep going back and forth on is where the folder goes.&lt;/p&gt;

&lt;p&gt;In Styx I put it next to the project, not inside it. For a repo at &lt;code&gt;~/code/shop&lt;/code&gt;, a Claude task gets &lt;code&gt;~/code/.styx/worktrees/shop/agent-claude-1&lt;/code&gt;, on the branch &lt;code&gt;agent/claude-1&lt;/code&gt;. The folder you have open in your editor never sees it: no branch switches, no half-finished edits in your working tree, so you can keep coding on your own branch while three agents work on theirs.&lt;/p&gt;

&lt;p&gt;The cost is that the agent's folder isn't the one your editor has open. You open it on purpose, with an "Open in" button on the task, and edits you make there are listed apart from the agent's own.&lt;/p&gt;

&lt;p&gt;There's one place your main folder does come back in: merging. Landing a task merges its branch into &lt;code&gt;main&lt;/code&gt; in the project folder you added, so that folder has to be on &lt;code&gt;main&lt;/code&gt; with nothing uncommitted. If it isn't, Styx says so and does nothing, rather than merge over your work.&lt;/p&gt;

&lt;p&gt;So my current answer is "next to the repo, and your checkout is only touched at the last step". I can see the case for the opposite: inside the repo, gitignored, so everything for one project is under one directory.&lt;/p&gt;

&lt;p&gt;Where do you put yours: inside the repo, next to it, or somewhere temporary? And what made you pick that?&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>git</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>Should a coding agent draw the screens before it writes the code?</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Mon, 09 Nov 2026 14:02:44 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/should-a-coding-agent-draw-the-screens-before-it-writes-the-code-c12</link>
      <guid>https://dev.to/nicholasflemmer/should-a-coding-agent-draw-the-screens-before-it-writes-the-code-c12</guid>
      <description>&lt;p&gt;For a new screen, the usual way with a coding agent is to describe it and let it build. You find out what it looks like when it runs, and fix it from there.&lt;/p&gt;

&lt;p&gt;The other way is to have the agent draw the screen first and only then build it. In Styx that's a design task: the agent produces ordinary HTML files in the task's branch, at desktop, tablet and phone widths (1280, 834 and 390 pixels). You look at them on a canvas, click what's wrong and say what to change.&lt;/p&gt;

&lt;p&gt;What I like about it is that the design is cheap to change. Moving a button on a drawn screen is one message, and a build task that already exists gets told when the design changes. What I don't like is the extra step. For a small change it's slower than just building it.&lt;/p&gt;

&lt;p&gt;So I use it when a screen is new or has several states, and skip it for tweaks.&lt;/p&gt;

&lt;p&gt;Do you design first, or let the agent build and fix it afterwards? And where does your cut-off sit?&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>design</category>
      <category>frontend</category>
    </item>
    <item>
      <title>Agent instructions: in the repo or in the tool?</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Sun, 08 Nov 2026 14:02:23 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/agent-instructions-in-the-repo-or-in-the-tool-50bn</link>
      <guid>https://dev.to/nicholasflemmer/agent-instructions-in-the-repo-or-in-the-tool-50bn</guid>
      <description>&lt;p&gt;There are two places to put the standing rules you want a coding agent to follow: in a file in the repo, or built into the tool that runs the agent. I've ended up with both, and they trade off differently.&lt;/p&gt;

&lt;p&gt;In the repo, the rules are versioned. They show up in pull requests, the whole team sees them, and they travel with a clone. The cost is that you write and maintain them per project, and they're only as good as the last person who edited them.&lt;/p&gt;

&lt;p&gt;In the tool, they work in every project and for every agent with no setup. The cost is that they're invisible: nobody reviews a diff of them, and they can clash with how a particular repo does things.&lt;/p&gt;

&lt;p&gt;Styx does the second kind. It builds in guidance from a few public repos: Ponytail for coding, Impeccable for interfaces, design-critique for reviewing a design, and architecture-designer for system design. Only the core rules are included, each applies only to that kind of work, and your project's own design system and rules come first.&lt;/p&gt;

&lt;p&gt;That last part is the rule I'd defend: when the two disagree, the repo wins, because it knows the project and the tool doesn't.&lt;/p&gt;

&lt;p&gt;Do you agree, or do you let the tool override the repo?&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>programming</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>Don't call a login expired after one failed check</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Sat, 07 Nov 2026 14:02:55 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/dont-call-a-login-expired-after-one-failed-check-57am</link>
      <guid>https://dev.to/nicholasflemmer/dont-call-a-login-expired-after-one-failed-check-57am</guid>
      <description>&lt;p&gt;Styx connects to Vercel, AWS, Supabase and others through the logins you already have, and agents ask to use them. A login can expire without telling anyone, so Styx checks every connected target every 30 minutes, when you bring the app to the front, and when the computer wakes.&lt;/p&gt;

&lt;p&gt;The obvious version of that is easy to get wrong: a check fails, so mark the target expired. But a check also fails when the wifi drops, or when the laptop has just woken up and has no network yet. Mark it expired then, and you've told the user their login is broken when it isn't.&lt;/p&gt;

&lt;p&gt;So the two kinds of failure are treated differently. A brief network failure doesn't count. Only a real authentication failure counts, and it has to show up in two checks in a row. The exceptions are when you press Refresh, or when a grant can't be issued because the CLI is signed out. Those count the first time, because you've just asked.&lt;/p&gt;

&lt;p&gt;When a target is marked expired, an agent that asks for it gets an error telling it to reconnect in Styx. Once you sign in again, every other target on the same account is checked again, so one login clears all of them.&lt;/p&gt;

&lt;p&gt;The trade-off is delay: a real expiry can go unnoticed for a while, since the checks are 30 minutes apart. I'd rather have that than a false alarm that pauses an agent.&lt;/p&gt;

</description>
      <category>debugging</category>
      <category>security</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>A 100% coverage threshold that CI never ran</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Fri, 06 Nov 2026 14:02:23 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/a-100-coverage-threshold-that-ci-never-ran-4cp2</link>
      <guid>https://dev.to/nicholasflemmer/a-100-coverage-threshold-that-ci-never-ran-4cp2</guid>
      <description>&lt;p&gt;The core package in Styx has a 100% coverage threshold in its config. It turned out CI never ran coverage, so nothing enforced the number. The selector tests had quietly fallen short.&lt;/p&gt;

&lt;p&gt;The fix came in as a pull request. It added tests for the selector behaviour that was missing, and added one command to the CI matrix: &lt;code&gt;pnpm -F @styx/core exec vitest run --coverage&lt;/code&gt;. After it, 664 tests pass with 1390 of 1390 statements and 1102 of 1102 branches covered.&lt;/p&gt;

&lt;p&gt;The part I like is what it did with the branches it couldn't cover. A few fallbacks were unreachable, so it simplified them away instead of writing contrived tests for them. The observable results stayed the same, and the code got smaller.&lt;/p&gt;

&lt;p&gt;Two lessons. A threshold in a config file is a wish until the command that enforces it runs in CI. And when the last few percent won't go green, ask whether that code can run at all.&lt;/p&gt;

&lt;p&gt;I only ask for 100% on the pure packages, the state machines, policy and selectors, where it's cheap. I wouldn't ask it of UI code.&lt;/p&gt;

</description>
      <category>cicd</category>
      <category>javascript</category>
      <category>testing</category>
    </item>
    <item>
      <title>Make the expensive feature opt-in, and let people switch it on where they need it</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Thu, 05 Nov 2026 14:02:30 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/make-the-expensive-feature-opt-in-and-let-people-switch-it-on-where-they-need-it-1j9j</link>
      <guid>https://dev.to/nicholasflemmer/make-the-expensive-feature-opt-in-and-let-people-switch-it-on-where-they-need-it-1j9j</guid>
      <description>&lt;p&gt;Some features cost something even when you aren't using them. In Styx, tracking every file an agent edits, so you can review it hunk by hunk, needs watchers on the task's worktree. On large changes those watchers can slow things down, so tracking is off by default.&lt;/p&gt;

&lt;p&gt;The trade-off showed up on the Review screen. Open it with tracking off and you got an empty state with a button that sent you to Settings. You leave what you were doing, find the switch, flip it, and come back.&lt;/p&gt;

&lt;p&gt;The fix was small. The button now turns tracking on through the same settings command and stays on Review. The default is unchanged, and nobody pays for the watchers until they ask for the screen that needs them.&lt;/p&gt;

&lt;p&gt;The rule I took from it: if a feature is off by default for a good reason, the place where its absence hurts should be able to switch it on. Sending someone to Settings is a dead end dressed up as a link.&lt;/p&gt;

&lt;p&gt;The cost is that the switch now lives in two places, so the copy and the tests have to agree about what it does. I'd still take that over a hidden setting.&lt;/p&gt;

&lt;p&gt;Where do you draw the line between a sensible default and a setting people have to hunt for?&lt;/p&gt;

</description>
      <category>architecture</category>
      <category>softwaredevelopment</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>When is a coding agent's task actually done?</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Wed, 04 Nov 2026 14:02:26 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/when-is-a-coding-agents-task-actually-done-kpp</link>
      <guid>https://dev.to/nicholasflemmer/when-is-a-coding-agents-task-actually-done-kpp</guid>
      <description>&lt;p&gt;An agent stops typing and the spinner goes away. Is the task finished?&lt;/p&gt;

&lt;p&gt;It's tempting to say yes. It isn't: the agent has only run out of things to do and is waiting for my next message. I haven't read the diff, the checks haven't run on the merged result, and nothing is on main.&lt;/p&gt;

&lt;p&gt;So I treat 'done' as something I decide, not something the agent signals. When I'm happy with the changes, I mark the task done, and that's the point where it becomes ready to merge. Until then, an agent that went quiet is just a quiet agent.&lt;/p&gt;

&lt;p&gt;The other side has a cost. If nothing ever closes a task for you, the 'waiting' ones pile up and you forget what's in them. In the tool I build, Styx, finished tasks archive themselves after seven days, which keeps the list from growing without end.&lt;/p&gt;

&lt;p&gt;So what's your rule? Do you call it done when the agent stops, when the tests pass, when you've read the diff, or something else?&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>productivity</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>Letting a coding agent use SSH without giving it your key</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Tue, 03 Nov 2026 14:02:40 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/letting-a-coding-agent-use-ssh-without-giving-it-your-key-57hm</link>
      <guid>https://dev.to/nicholasflemmer/letting-a-coding-agent-use-ssh-without-giving-it-your-key-57hm</guid>
      <description>&lt;p&gt;When a coding agent needs to reach a server, the easy options are both bad. You can leave a key where the agent can read it, or you can tell it to use your normal ssh setup and hope it only does what you meant.&lt;/p&gt;

&lt;p&gt;I build Styx, a free and open-source desktop app that runs coding agents and makes them ask before they touch production. This is how it handles SSH, what the agent actually gets, and where the protection ends.&lt;/p&gt;

&lt;h2&gt;
  
  
  A target, not a key
&lt;/h2&gt;

&lt;p&gt;An SSH target in Styx is a host, a user, a port (22 by default), an optional jump host (&lt;code&gt;user@bastion:22&lt;/code&gt;, comma-separated for several) and an environment: prod, staging or preview. Agents don't get a special tool. They run plain &lt;code&gt;ssh &amp;lt;host&amp;gt;&lt;/code&gt;, &lt;code&gt;scp&lt;/code&gt;, &lt;code&gt;sftp&lt;/code&gt; or &lt;code&gt;rsync&lt;/code&gt;, and Styx applies the target's user, port and jump host for them. If the agent gives itself a user or a port, its choice wins.&lt;/p&gt;

&lt;p&gt;That is the 0.4.19 change: connecting SSH servers with their saved user and port, by key, password or your own setup.&lt;/p&gt;

&lt;h2&gt;
  
  
  Three ways to sign in
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Key file.&lt;/strong&gt; Styx stores the key's path and passphrase in the OS keychain. It does not store the key. Each time a grant is issued it reads the key from disk. The agent never gets the key file: it gets a forwarded SSH agent socket that works for the lifetime of the grant.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Password.&lt;/strong&gt; The password lives in the keychain. When you grant access, Styx signs in to the server itself and the agent uses that connection, so it never sees the password. This isn't available on Windows, whose ssh can't share a signed-in connection. There you use a key file or your own setup.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;My SSH setup.&lt;/strong&gt; Nothing is stored. ssh uses your own agent and &lt;code&gt;~/.ssh/config&lt;/code&gt;, so 1Password, hardware keys, certificates and keys you already use all keep working. Since Styx stores nothing in this mode, what your own agent and config can reach is up to them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Test connection signs in the way an agent will
&lt;/h2&gt;

&lt;p&gt;The form has a Test connection button that signs in exactly the way an agent will. If the server only accepts passwords and you chose a key, it says so, and says how to add your key to the server. I'd rather find that out on the form than in the middle of an agent's task.&lt;/p&gt;

&lt;h2&gt;
  
  
  Asking, and who decides
&lt;/h2&gt;

&lt;p&gt;A connected target doesn't mean the agent can use it. It has to ask, say why, and you choose what it gets: once, for an hour or for the session. For SSH on a prod target the grant hands over your whole credential whatever scope was asked, so Styx turns any auto-approval into an ask with Touch ID, Windows Hello or your system password, reads included. Every request, grant, use and revoke goes into an append-only audit log.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where it stops
&lt;/h2&gt;

&lt;p&gt;Styx is a guardrail, not a sandbox. Agents run as you, on your machine. The &lt;code&gt;ssh&lt;/code&gt; command the agent runs by name hits a shim that asks first, but an agent that calls the real binary by its full path goes around it. Claude Code and Codex get a warning in the chat when Styx sees it, not a block. What Styx guarantees is that it never hands an agent your key and that every grant it gives is scoped, timed and written down.&lt;/p&gt;

&lt;p&gt;The code is at &lt;a href="https://github.com/NicholasFlemmer/styx-app" rel="noopener noreferrer"&gt;https://github.com/NicholasFlemmer/styx-app&lt;/a&gt; and the page on connecting targets is &lt;a href="https://heystyx.com/docs/access/connect-a-target" rel="noopener noreferrer"&gt;https://heystyx.com/docs/access/connect-a-target&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;How do you let an agent reach a server today: a separate key, your own agent, or something else?&lt;/p&gt;

</description>
      <category>agents</category>
      <category>automation</category>
      <category>opensource</category>
      <category>security</category>
    </item>
    <item>
      <title>Is 'signed in' the same as 'working'? Checking a coding agent's login</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Mon, 02 Nov 2026 15:03:05 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/is-signed-in-the-same-as-working-checking-a-coding-agents-login-2b2o</link>
      <guid>https://dev.to/nicholasflemmer/is-signed-in-the-same-as-working-checking-a-coding-agents-login-2b2o</guid>
      <description>&lt;p&gt;A coding agent CLI can say it's signed in and still not work: the account has no plan for it, or it's out of usage until the limit resets.&lt;/p&gt;

&lt;p&gt;So in Styx, the app I'm building, 'Ready' means more than 'signed in'. During setup it runs the vendor's own installer and sign-in, then sends one tiny message and waits for the answer. If the answer comes back, the plan really works. If it says 'needs a plan' or 'out of usage', the card says that in one sentence, with the fix.&lt;/p&gt;

&lt;p&gt;Two things I learned doing it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Never write your own login flow for someone else's CLI.&lt;/strong&gt; Run their installer and their sign-in, and keep only where the binary lives and which account it reports. Passwords and tokens stay with the vendor.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Some CLIs have no cheap check.&lt;/strong&gt; Goose has no offline identity probe, and its provider check spends a model turn. Amp has none either. For those, the row says 'not verified' and still lets you start a task, because a green tick I can't back up is worse than an honest grey one.&lt;/p&gt;

&lt;p&gt;The tradeoff is that the tiny message costs a few tokens on a real plan, so I only send it during setup and when you ask.&lt;/p&gt;

&lt;p&gt;How do you check that an agent CLI works before you hand it a real task?&lt;/p&gt;

</description>
      <category>agents</category>
      <category>cli</category>
      <category>coding</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>What's new in Styx 0.4.20</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Mon, 02 Nov 2026 13:03:44 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/whats-new-in-styx-0420-3fed</link>
      <guid>https://dev.to/nicholasflemmer/whats-new-in-styx-0420-3fed</guid>
      <description>&lt;p&gt;Styx 0.4.20 is out. Styx runs Claude Code, Codex, Gemini CLI, Cursor and OpenCode on all your projects in one window, each task on its own branch, and agents ask before they touch production. Free and open source (Apache-2.0); Mac, with Windows and Linux in beta.&lt;/p&gt;

&lt;p&gt;What changed:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Update&lt;/li&gt;
&lt;li&gt;Refuse SSH commands with the reason when a target cannot connect, and pick the target by host&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Full release notes and downloads: &lt;a href="https://github.com/NicholasFlemmer/styx-app/releases/tag/v0.4.20" rel="noopener noreferrer"&gt;https://github.com/NicholasFlemmer/styx-app/releases/tag/v0.4.20&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Code: &lt;a href="https://github.com/NicholasFlemmer/styx-app" rel="noopener noreferrer"&gt;https://github.com/NicholasFlemmer/styx-app&lt;/a&gt; · Site: &lt;a href="https://heystyx.com" rel="noopener noreferrer"&gt;https://heystyx.com&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;If you run into anything, issues and discussions on GitHub are the best place; I read all of them.&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>opensource</category>
      <category>tools</category>
    </item>
    <item>
      <title>Would you let a coding agent merge its own work into main?</title>
      <dc:creator>Nic Flemmer</dc:creator>
      <pubDate>Sun, 01 Nov 2026 15:00:08 +0000</pubDate>
      <link>https://dev.to/nicholasflemmer/would-you-let-a-coding-agent-merge-its-own-work-into-main-8c6</link>
      <guid>https://dev.to/nicholasflemmer/would-you-let-a-coding-agent-merge-its-own-work-into-main-8c6</guid>
      <description>&lt;p&gt;After a turn, a coding agent leaves changes on its branch. If your tests pass, why not let it merge them?&lt;/p&gt;

&lt;p&gt;I added exactly that setting to a tool I'm building, Styx: 'Land on its own when the agent goes quiet and the checks pass'. It's off by default. With it on, each time an agent finishes a turn with changes, Styx brings main into the branch, runs the project's checks and merges only if they pass. A failure stops it before main is touched, and the chat says why.&lt;/p&gt;

&lt;p&gt;The obvious problem is that the checks are only as good as the tests. And the agent may have written some of those tests itself, so green can mean 'it agrees with itself'.&lt;/p&gt;

&lt;p&gt;The argument for it is that a quick merge of a small, checked change is how people already work on a branch they own, and a bad merge is a revert away.&lt;/p&gt;

&lt;p&gt;So where's your line?&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Never. I read the diff every time.&lt;/li&gt;
&lt;li&gt;On a side project, with green tests.&lt;/li&gt;
&lt;li&gt;Only for changes a second agent has reviewed.&lt;/li&gt;
&lt;li&gt;Only for certain kinds of change, like docs or tests.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Would you turn it on, and what would it need to have checked first?&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>automation</category>
      <category>git</category>
    </item>
  </channel>
</rss>
