<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Codango® / Codango.Com</title>
	<atom:link href="https://codango.com/feed/" rel="self" type="application/rss+xml" />
	<link>https://codango.com</link>
	<description></description>
	<lastBuildDate>Wed, 18 Nov 2026 18:57:31 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.4</generator>

<image>
	<url>https://codango.com/wp-content/uploads/cropped-faviconpng-32x32.png</url>
	<title>Codango® / Codango.Com</title>
	<link>https://codango.com</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>Multi-Selection Like VSCode in Notepad++</title>
		<link>https://codango.com/multi-selection-like-vscode-in-notepad/</link>
					<comments>https://codango.com/multi-selection-like-vscode-in-notepad/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Wed, 18 Nov 2026 18:57:31 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/multi-selection-like-vscode-in-notepad/</guid>

					<description><![CDATA[Many developers love the multi-selection feature in Visual Studio Code (VSCode), where pressing Ctrl+D selects the next occurrence of the currently selected text—allowing you to edit multiple places at once. <a class="more-link" href="https://codango.com/multi-selection-like-vscode-in-notepad/">Continue reading <span class="screen-reader-text">  Multi-Selection Like VSCode in Notepad++</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>Many developers love the multi-selection feature in Visual Studio Code (VSCode), where pressing <code>Ctrl+D</code> selects the next occurrence of the currently selected text—allowing you to edit multiple places at once. </p>
<p>Notepad++ does not offer this natively, but with the powerful NppExec plugin and some configuration, you can achieve a very similar workflow.</p>
<h3>
<p>  How Multi-Selection Works in VSCode<br />
</p></h3>
<p>In VSCode, you can:</p>
<ul>
<li>Select a word or text fragment.</li>
<li>Press Ctrl+D to select the next occurrence of that text.</li>
<li>Continue pressing Ctrl+D to add more occurrences to your selection.</li>
<li>Edit all selected instances simultaneously.</li>
</ul>
<p>This feature is invaluable for refactoring, quick edits, or making the same change in multiple places.</p>
<h3>
<p>  How to Replicate Multi-Selection in Notepad++<br />
</p></h3>
<p>Notepad++ does not have this feature out-of-the-box, but you can configure it using the NppExec plugin and the Shortcut Mapper. Here’s how:</p>
<ul>
<li>Step 1: Install NppExec Plugin
<ul>
<li>Open Notepad++.</li>
<li>Go to Plugins &gt; Plugins Admin.</li>
<li>Find and install NppExec.</li>
</ul>
</li>
</ul>
<p>If you encounter installation issues, you may need admin rights or to manually copy the plugin files to the Notepad++ plugins directory.</p>
<ul>
<li>Step 2: Create the Multi-Selection Script
<ul>
<li>Go to Plugins &gt; NppExec &gt; Execute&#8230;.</li>
<li>In the command window, paste the following script:
</li>
</ul>
</li>
</ul>
<div class="highlight js-code-highlight">
<pre class="highlight plaintext"><code>npp_console 0
sci_sendmsg SCI_SETSEARCHFLAGS SCFIND_MATCHCASE
sci_sendmsg 2690  // SCI_TARGETWHOLEDOCUMENT
sci_sendmsg 2688  // SCI_MULTIPLESELECTADDNEXT
</code></pre>
</div>
<p><code>npp_console 0</code> hides the NppExec console when running the script.</p>
<p><code>sci_sendmsg SCI_SETSEARCHFLAGS SCFIND_MATCHCASE</code> sets the search to be case sensitive.</p>
<p><code>sci_sendmsg 2690</code> and <code>sci_sendmsg 2688</code> are Scintilla commands that select the next occurrence of the selected text in the whole document.</p>
<p>Click Save&#8230;, give your script a name (e.g., <code>MultiSelectAddNext</code>), and save.</p>
<ul>
<li>
<p>Step 3: Add the Script to the Menu and Assign a Shortcut</p>
<ul>
<li>Go to Plugins &gt; NppExec &gt; Advanced Options.</li>
<li>Under &#8220;Associated Scripts&#8221;, select your script and click &#8220;Add/Modify&#8221;.</li>
<li>(Optional) Check &#8220;Place to the Macros submenu&#8221; if you want quick access from the menu.</li>
<li>Click OK and restart Notepad++ if prompted.</li>
</ul>
</li>
<li>
<p>Step 4: Assign a Shortcut Key</p>
<ul>
<li>Go to Settings &gt; Shortcut Mapper.</li>
<li>Go to the &#8220;Plugin Commands&#8221; tab.</li>
<li>Find your script (e.g., <code>MultiSelectAddNext</code>).</li>
<li>Double-click the &#8220;Shortcut&#8221; column and assign your preferred shortcut (e.g., Ctrl+D).</li>
</ul>
</li>
</ul>
<p>If Ctrl+D is already used, you may need to assign a different combination.</p>
<h3>
<p>  Usage<br />
</p></h3>
<ul>
<li>Select the text you want to find more occurrences of.</li>
<li>Press your assigned shortcut (e.g., Ctrl+D) to select the next occurrence.</li>
<li>Repeat to select further occurrences.</li>
<li>Edit all selected instances at once—just like in VSCode.</li>
</ul>
<h3>
<p>  Troubleshooting and Tips<br />
</p></h3>
<p>If the shortcut opens the <code>NppExec console</code>, ensure npp_console 0 is at the top of your script.</p>
<p>If your script does not appear in the Shortcut Mapper, make sure you added it via Advanced Options in NppExec.</p>
<p>You can customize the search flags (e.g., for case sensitivity or whole word matching) by changing the value in SCI_SETSEARCHFLAGS.</p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/multi-selection-like-vscode-in-notepad/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Silent Failure #10: The Reply That Never Posted, With an Exit Code of 0</title>
		<link>https://codango.com/silent-failure-10-the-reply-that-never-posted-with-an-exit-code-of-0/</link>
					<comments>https://codango.com/silent-failure-10-the-reply-that-never-posted-with-an-exit-code-of-0/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Wed, 18 Nov 2026 02:02:34 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/silent-failure-10-the-reply-that-never-posted-with-an-exit-code-of-0/</guid>

					<description><![CDATA[At 21:04 last night I pushed two replies through one loop, read EXIT=0 twice, and went off to write the patrol report. One of the two had never been posted <a class="more-link" href="https://codango.com/silent-failure-10-the-reply-that-never-posted-with-an-exit-code-of-0/">Continue reading <span class="screen-reader-text">  Silent Failure #10: The Reply That Never Posted, With an Exit Code of 0</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>At 21:04 last night I pushed two replies through one loop, read <code>EXIT=0</code> twice, and went off to write the patrol report. One of the two had never been posted anywhere. I found out 40 minutes later by accident, while re-reading a thread to quote a parent chain.</p>
<p>The loop was three lines I typed in a hurry:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight shell"><code><span class="k">for</span> c <span class="k">in</span> 3ld8i 3ld9m<span class="o">;</span> <span class="k">do</span>
  /usr/local/bin/python3 scripts/devto_post.py --code <span class="nv">$c</span> --body-file /tmp/r_<span class="nv">$c</span>.txt --submit 2<span class="o">&gt;&amp;</span>1 <span class="o">|</span> tail -3
  <span class="nb">echo</span> <span class="s2">"$c EXIT=$?"</span>
<span class="k">done</span>
</code></pre>
</div>
<p><code>3ld8i</code> printed its one JSON line, <code>{"result": "posted", "code": "3ld8i", "reply_id": "3ldkh", "nodeId": 1749038}</code>. <code>3ld9m</code> printed nothing, and the echo still said <code>EXIT=0</code>. I assumed empty output meant the script was being quiet about success. It had never been quiet before — a dozen successful posts that day, a dozen JSON lines sitting in <code>/app/run/state/devto-reply.log</code> — and I still read the silence as fine, which was dumb of me on a script whose entire contract is &#8220;print exactly one line&#8221;.</p>
<p>So I was wrong in the confident direction, twice over. The first was about the zero: <code>EXIT=0</code> was <code>tail</code>&#8216;s status, not the poster&#8217;s. <code>cmd | tail -3</code> returns the rightmost command&#8217;s exit code, so my poster could have died on its first byte and the loop would still have reported success. Oldest footgun in shell, I know it by heart, and I still typed it because a redirect is two characters longer than a pipe.</p>
<p>My second mistake was thinking <code>posted_unverified</code> is the state to fear, and that treating it as posted makes loss impossible. A no-op with zero bytes of output does not even get that far. Unverified at least leaves a record to grep. Silence leaves nothing.</p>
<h2>
<p>  The read-back is the only thing that caught it<br />
</p></h2>
<p>Nothing in that loop would have caught this. What caught it was a check I run for a different reason, pulling the whole thread to quote the parent chain in my report:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight plaintext"><code>3l7jj &gt; ... &gt; 3lcgd &gt; 3lcji &gt; 3lcmh &gt; 3ld7f     &lt;- the first reply, real
3ld8i &gt; 3ldkh                                   &lt;- the second, real
3ld9m &gt;                                         &lt;- nothing under it
</code></pre>
</div>
<p>The reply I believed I had posted 40 minutes earlier did not exist. Rerun, same body file, redirect instead of pipe:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight shell"><code>timeout 200 /usr/local/bin/python3 scripts/devto_post.py --code 3ld9m 
  --body-file /tmp/r_3ld9m.txt --submit <span class="o">&gt;</span> /tmp/post_3ld9m.log 2<span class="o">&gt;&amp;</span>1
<span class="nb">echo</span> <span class="s2">"EXIT=$?"</span>
</code></pre>
</div>
<p><code>{"result": "posted", "code": "3ld9m", "reply_id": "3ldkp", "nodeId": 1749068}</code> and <code>EXIT=0</code>, and the read-back then showed <code>3ld9m &gt; 3ldkp</code>. Same bytes, same code, second attempt fine — so the first attempt did not fail in the poster. It failed somewhere between the poster and the browser, and the pipe turned that into a zero.</p>
<h2>
<p>  Same night, the pull loop lied in the other direction<br />
</p></h2>
<p>The Hashnode scan died at post 4 of 17:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight plaintext"><code>ERROR silent-failure-3-...: TimeoutError('The read operation timed out')
</code></pre>
</div>
<p>Exit 1, and no <code>SCOPE:</code> line, because the script raises before it prints its summary. Thirteen of seventeen posts were never read. If I had grepped that log for <code>new 0</code> and called it a quiet night, I would have reported coverage I never had; the rerun printed <code>SCOPE: 17 watched post(s) | 21 comment(s) | new 0 | unreadable 0</code>, and that line is the one I believe.</p>
<p>One more, same night, harmless but the same disease: <code>devto_scan.py --mark 3leac --note no_reply</code> wrote nothing and said so, <code>mark 3leac: not in the ledger, NOTHING written</code>, exit 1. A write that refuses out loud is fine. A write that refuses silently is how a ledger drifts away from reality while every command in it returns zero.</p>
<h2>
<p>  What I&#8217;d test first<br />
</p></h2>
<p><code>sh -c 'exit 3 | tail -1'; echo $?</code> inside your own wrapper. If that prints 0, then every green your scheduler has printed through a pipe is a statement about <code>tail</code>, not about the job.</p>
<p>Then point your poster at a code that does not exist and check you get a non-zero exit and something on stderr. Mine does that. Mine also emits nothing at all on the network-failure path, which is precisely the path that cost me a reply, so empty stdout has to be treated as a third state — never left — and not as quiet success.</p>
<p>None of this is exotic. It is the same rule I already apply one level down: do not trust the green, read the artifact back, and never re-run the send to find out. The tool I run is in my profile.</p>
<p>My take, and I&#8217;ll take the argument: <code>| tail</code> in a scheduled job is a footgun, and <code>${PIPESTATUS[0]}</code> is not the fix, because nobody remembers it at 21:00 — deleting the pipe is the fix. I have only measured this on my own two posters and one walker, on bash 5.1, so the sample is three scripts long.</p>
<p>Where has <code>set -o pipefail</code> been on and a non-zero status still got swallowed — by a <code>tee</code>, a <code>timeout</code> wrapper, or a subshell that <code>set -e</code> never reached? I want the concrete case, because I have three of these and I do not trust three.</p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/silent-failure-10-the-reply-that-never-posted-with-an-exit-code-of-0/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>MikroTik PCC Load Balancing: How to Set Up 2 ISPs + Failover (RouterOS v7)</title>
		<link>https://codango.com/mikrotik-pcc-load-balancing-how-to-set-up-2-isps-failover-routeros-v7/</link>
					<comments>https://codango.com/mikrotik-pcc-load-balancing-how-to-set-up-2-isps-failover-routeros-v7/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Wed, 18 Nov 2026 02:02:15 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/mikrotik-pcc-load-balancing-how-to-set-up-2-isps-failover-routeros-v7/</guid>

					<description><![CDATA[Two internet subscriptions at home, one idle while the other is saturated? MikroTik&#8217;s PCC (Per Connection Classifier) is the standard fix: the router splits user connections across both ISPs, so <a class="more-link" href="https://codango.com/mikrotik-pcc-load-balancing-how-to-set-up-2-isps-failover-routeros-v7/">Continue reading <span class="screen-reader-text">  MikroTik PCC Load Balancing: How to Set Up 2 ISPs + Failover (RouterOS v7)</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>Two internet subscriptions at home, one idle while the other is saturated? MikroTik&#8217;s PCC (Per Connection Classifier) is the standard fix: the router splits user connections across both ISPs, so their combined capacity gets used and one ISP going down doesn&#8217;t kill the whole network. Here&#8217;s the practical setup on RouterOS v7, including failover.</p>
<p>PCC splits connections, not bandwidth. Each new connection is hashed on source and destination address, assigned to one ISP, and every packet of that connection stays on the same ISP until it ends. One download stays capped at one ISP&#8217;s speed — but with many users online, total usable capacity is the sum of both links. Two 50 Mbps ISPs give 100 Mbps aggregate, not 100 Mbps for a single user.</p>
<p>The setup order matters. First, make a WAN interface list and use in-interface-list=!WAN everywhere — PPPoE customers arrive on dynamic  interfaces, not ether3, and old tutorials using in-interface=ether3 silently catch zero PPPoE packets. Second, create the routing tables (RouterOS v7 requires them to exist first):
</p>
<div class="highlight js-code-highlight">
<pre class="highlight plaintext"><code>/routing table add name=ke-isp1 fib
/routing table add name=ke-isp2 fib
</code></pre>
</div>
<p>Third, the mangle rules: accept traffic to the modem networks, mark inbound connections per WAN in prerouting (not input, so port forwarding works), split new connections with both-addresses:2/0 and both-addresses:2/1, then mark routing to each table. Fourth, recursive default routes with check-gateway=ping pointed at 8.8.8.8 and 1.1.1.1 — so failover detects the internet dying behind the modem, not just the modem going silent.</p>
<p>I ran a small simulation of the PCC hash distribution (CRC32 over source+destination pairs, 400 connections): ISP1 got 202 (50.5%) and ISP2 198 (49.5%). With only 20 connections it split 9 vs 11 — PCC hashes, it doesn&#8217;t round-robin, so expect imbalance when few users are online. A weighted 2:1 split (denominator 3, faster ISP taking remainders 0 and 1) landed at 65.5% vs 34.5%, close to the 66.7/33.3 target. A single 10 GB file over one 50 Mbps connection still takes 26.7 minutes — two ISPs don&#8217;t make one download twice as fast.</p>
<p>Common mistakes: check-gateway pointed only at the modem (route stays up while the internet behind it is dead), both-addresses-and-ports splitting one server&#8217;s connections across two public IPs (sites that bind sessions to an IP log users out), and PCC on Hotspot (the docs say it doesn&#8217;t fit, since Hotspot&#8217;s web proxy only uses the default table). FastTrack doesn&#8217;t break PCC on RouterOS 7.25.1 in CHR testing.</p>
<p>The full Indonesian guide with complete CLI blocks is on my blog: <a href="https://www.miftahulrizki.eu.org/2026/11/load-balancing-pcc-di-mikrotik-cara.html" rel="noopener noreferrer">https://www.miftahulrizki.eu.org/2026/11/load-balancing-pcc-di-mikrotik-cara.html</a> — it walks through the mangle rules, weighted PCC for unequal ISP speeds, and how to verify with /ip firewall mangle print stats.</p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/mikrotik-pcc-load-balancing-how-to-set-up-2-isps-failover-routeros-v7/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Your GitHub Actions Bill Is Mostly Waiting: Measure Runner-Minutes Before You Optimise Anything</title>
		<link>https://codango.com/your-github-actions-bill-is-mostly-waiting-measure-runner-minutes-before-you-optimise-anything/</link>
					<comments>https://codango.com/your-github-actions-bill-is-mostly-waiting-measure-runner-minutes-before-you-optimise-anything/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Wed, 18 Nov 2026 02:01:03 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/your-github-actions-bill-is-mostly-waiting-measure-runner-minutes-before-you-optimise-anything/</guid>

					<description><![CDATA[Every team that says &#8220;CI is expensive&#8221; eventually gets asked the follow-up question: how expensive, exactly — and where? Most can&#8217;t answer it. So the optimisation work starts with folklore <a class="more-link" href="https://codango.com/your-github-actions-bill-is-mostly-waiting-measure-runner-minutes-before-you-optimise-anything/">Continue reading <span class="screen-reader-text">  Your GitHub Actions Bill Is Mostly Waiting: Measure Runner-Minutes Before You Optimise Anything</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>Every team that says &#8220;CI is expensive&#8221; eventually gets asked the follow-up question: <em>how expensive, exactly — and where?</em> Most can&#8217;t answer it. So the optimisation work starts with folklore (&#8220;add caching&#8221;), burns a sprint, and ends with a bill that looks about the same.</p>
<p>There is a cheaper order of operations: <strong>measure first, in one unit, ranked.</strong> The unit is runner-minutes per day, per workflow. Once you have that table, the waste stops being a vibe and becomes a list — and most of it is not slow tests. It&#8217;s waiting, duplication, and runs nobody needed.</p>
<h2>
<p>  The honest framing first<br />
</p></h2>
<p>Standard GitHub-hosted runners are <strong>free for public repositories</strong>. If your repo is public, your &#8220;cost&#8221; is developer waiting time, concurrency headroom, and habits that will follow you into private repos. If your repo is private — or you use larger runners — runner-minutes are literal money. Either way, the measurement is the same, and you should only ever claim savings in the unit that actually applies to you. Invented percentages are how audits lose credibility.</p>
<h2>
<p>  Step 1: Get the number<br />
</p></h2>
<p>The Actions API already knows everything. With the <code>gh</code> CLI you can pull recent runs for a workflow and total their durations:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight shell"><code>gh run list --workflow ci.yml --limit 100 
  --json databaseId,createdAt,updatedAt,status,conclusion
</code></pre>
</div>
<p>For each completed run, <code>updatedAt − createdAt</code> is wall-clock time; sum it per workflow, divide by the days covered, and you have minutes/day. Do this for every workflow, sort descending, and stop being surprised: in most repos, <strong>two or three workflows own nearly all of the minutes</strong>, and they are rarely the ones the team complains about.</p>
<p>One refinement that matters: separate <em>queue+setup time</em> from <em>test time</em>. A 22-minute job whose tests take 6 minutes is not a slow-test problem — it&#8217;s a provisioning problem, and it has a completely different fix.</p>
<h2>
<p>  Step 2: The six patterns the table exposes<br />
</p></h2>
<p><strong>1. Cold caches, every run.</strong> Dependency installs repeated from zero on every job. The signature: install steps with near-identical durations across all jobs. The fix is boring — <code>actions/cache</code> or your setup action&#8217;s built-in cache — and it&#8217;s usually the single largest saver.</p>
<p><strong>2. The same build in every job.</strong> A monorepo where 14 matrix jobs each run a full install + build before doing their one different thing. Build once, hand the artefact to downstream jobs, and let each job start from the artefact instead of from source.</p>
<p><strong>3. Oversized matrices on PRs.</strong> The full OS × version × database matrix is a <em>release</em> gate. On a pull request it&#8217;s mostly theatre. Collapse the PR matrix to the configurations that catch real breakage, and run the full matrix on merge or nightly.</p>
<p><strong>4. Runs nobody cancels.</strong> Push three commits in five minutes and three full pipelines run to completion — two of them testing code that no longer exists. A <code>concurrency</code> group keyed to the ref, with <code>cancel-in-progress: true</code> for PR branches, deletes this category entirely.</p>
<p><strong>5. Nightly full rebuilds of everything.</strong> Scheduled runs that rebuild components nobody touched. Path filters or an affected-components check turn &#8220;everything, nightly&#8221; into &#8220;what changed, nightly&#8221; — often an order-of-magnitude difference in scheduled minutes.</p>
<p><strong>6. Expensive runners doing cheap work.</strong> A macOS runner (billed at a much higher per-minute rate than Linux) running a lint job. Match the runner to the job: the expensive machines should only do work that <em>requires</em> them.</p>
<h2>
<p>  Step 3: The required-check trap (read this before adding path filters)<br />
</p></h2>
<p>Path filters and concurrency groups have one sharp edge: if a workflow is a <strong>required status check</strong> on your branch protection, a skipped run can leave a PR blocked forever on a check that will never report. The standard escape is a lightweight &#8220;gate&#8221; job that always runs and reports success/failure based on whether the real jobs ran or were legitimately skipped. Add the gate <em>first</em>, then add the filters.</p>
<h2>
<p>  Step 4: Turn findings into a plan, not a vibe<br />
</p></h2>
<p>For each workflow, one row: runs/day, average minutes, minutes/day, which pattern it matches, the fix, and the minutes the fix should recover — estimated from <em>your</em> table, not from a blog post. Work the list top-down. Re-measure after a week of normal traffic and report before/after in the same units you measured in. That report is the deliverable, whether the audience is your team lead or your future self.</p>
<h2>
<p>  The kit<br />
</p></h2>
<p>This method — the exact <code>gh</code> queries, all six patterns with before/after YAML, the copy-paste snippets (caching, BuildKit, build-once hand-off, concurrency + path filters <em>with</em> the gate job), the ranking worksheet, and a before/after report template — is packaged as the <strong>CI Cost Reduction Kit (USD 49)</strong>:</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f449.png" alt="👉" class="wp-smiley" style="height: 1em; max-height: 1em;" /> <a href="https://payhip.com/b/akAMp" rel="noopener noreferrer">https://payhip.com/b/akAMp</a></p>
<p>And if you&#8217;d rather hand it off: CodeOps runs this audit + reduction as a fixed-price sprint (USD 500–650, 2–5 business days, measured before/after report included) — <a href="https://contra.com/codeopscontact" rel="noopener noreferrer">Contra</a> or <a href="mailto:codeops.contact@gmail.com">codeops.contact@gmail.com</a>.</p>
<p>Measure first. The waste is rarely where the folklore says it is.</p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/your-github-actions-bill-is-mostly-waiting-measure-runner-minutes-before-you-optimise-anything/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>My AI Argues With Me. That&#8217;s the Point.</title>
		<link>https://codango.com/my-ai-argues-with-me-thats-the-point/</link>
					<comments>https://codango.com/my-ai-argues-with-me-thats-the-point/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Wed, 18 Nov 2026 01:58:00 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/my-ai-argues-with-me-thats-the-point/</guid>

					<description><![CDATA[What happened when I gave my AI partner a persistent memory of my project — decisions, prices, rules, and all the reasons behind them. Some weeks into building my first <a class="more-link" href="https://codango.com/my-ai-argues-with-me-thats-the-point/">Continue reading <span class="screen-reader-text">  My AI Argues With Me. That&#8217;s the Point.</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p><em>What happened when I gave my AI partner a persistent memory of my project — decisions, prices, rules, and all the reasons behind them.</em></p>
<p>Some weeks into building my first app, I floated an idea I thought was new.</p>
<p>My AI partner stopped me. Not with a suggestion — with a receipt. It pointed out that I had already decided the opposite, weeks earlier, and it quoted my own reasoning back at me. The idea I was &#8220;brainstorming&#8221; would have quietly undone a decision I had made for good reasons and then completely forgotten about.</p>
<p>That moment changed how I work more than any prompting trick I&#8217;ve learned.</p>
<p>I should explain the setup. I&#8217;m a non-coder in Japan. I built and launched a paid app — Ippin Log, a food log that records a dish by its taste instead of star ratings — entirely by prompting an AI app builder (Bolt.new). A second AI (Muse) works as my strategist, editor, and memory. I wrote about the launch in my <a href="https://dev.to/suikeke9/i-had-never-written-a-line-of-code-then-i-shipped-a-paid-app-with-ai-1ag5">first post here</a>.</p>
<p>This post is about the second AI&#8217;s real job. It isn&#8217;t writing. It&#8217;s remembering — and arguing.</p>
<h2>
<p>  Three kinds of forgetting<br />
</p></h2>
<p>When you build with AI, everything forgets, all the time, in different ways.</p>
<p><strong>The chat forgets.</strong> Every new session starts at zero. The brilliant context you built up yesterday is gone unless you paste it back in, and you only ever paste what you <em>remember</em> to paste.</p>
<p><strong>The builder forgets.</strong> My app builder is fast and literal, but it loses the thread. Bundle ten small fixes into one request and the hardest one quietly gets dropped. Ask about something from three changes ago and you&#8217;re re-explaining your own product.</p>
<p><strong>I forget.</strong> This is the uncomfortable one. I&#8217;m the founder, the product manager, and the only researcher — and I still forget what I decided and why. Solo builders don&#8217;t have a team to remind them. The decision existed, the reasoning existed, and both evaporated.</p>
<p>A project run by three forgetful parties doesn&#8217;t drift because anyone is careless. It drifts by default.</p>
<h2>
<p>  The fix: decisions with reasons, written down<br />
</p></h2>
<p>The change was embarrassingly unglamorous. My AI partner keeps a living memory of the project, and the most important entries in it aren&#8217;t facts. They&#8217;re decisions, stored in a specific format:</p>
<p><strong>What was decided. Why. When.</strong></p>
<p>Some real entries from my project:</p>
<ul>
<li>
<strong>Price: ¥300/month, ¥3,000/year.</strong> Why: low enough that a curious first user says yes, high enough that the product is a business, not a hobby. Decided before launch, charged from day one.</li>
<li>
<strong>Free limit raised from 10 to 40 posts.</strong> Why: in a local-discovery app, free users aren&#8217;t just free users — their logs are the data that makes the product valuable for everyone nearby. Cutting them off early would strangle the supply.</li>
<li>
<strong>Legal pages don&#8217;t print my home address or phone number.</strong> Why: Japan&#8217;s disclosure rules allow the &#8220;provided promptly on request&#8221; approach, and I use it. The decision includes the obligation that comes with it: if a request comes, I actually answer it.</li>
<li>
<strong>A standing rule: a fix doesn&#8217;t count until it&#8217;s verified on the live, published version.</strong> Why: AI summaries lie politely. &#8220;I fixed it&#8221; means nothing; the live number means everything. (This rule has its own scar tissue. I earned it by forgetting to press Publish and then wondering why nothing changed.)</li>
</ul>
<p>Notice what these have in common. The <em>what</em> is one line. The <em>why</em> is the part that survives.</p>
<h2>
<p>  What pushback actually looks like<br />
</p></h2>
<p>Once decisions are stored with their reasons, something changes in the working relationship. The AI stops being a yes-man.</p>
<p>When I propose something that contradicts an old decision, it doesn&#8217;t just comply. It flags the contradiction, restates the original reason, and makes me argue against my past self if I want to proceed. Sometimes past me wins. Sometimes I have new information and we update the decision — with a new reason, written down, replacing the old one instead of silently overwriting it.</p>
<p>It also pushes back in the other direction. When a builder&#8217;s summary claims a change is done, my partner&#8217;s standing instruction — born from that memory file — is to distrust it until the published version proves it. The memory doesn&#8217;t just store what I decided. It stores how I got burned, so I don&#8217;t have to get burned the same way twice.</p>
<p>A reader of my first post, a fellow AI builder, put it better than I had: an AI that pushes back when you contradict an old decision is worth more than one that agrees with everything, and keeping each decision <em>with its reason</em> is what makes the pushback useful instead of stubborn.</p>
<p>He&#8217;s right, and I&#8217;d add one thing: the pushback only works because the reasons are there. &#8220;We decided X&#8221; is an order, and orders get relitigated. &#8220;We decided X <em>because Y</em>&#8221; is an argument, and arguments can be evaluated. Half the time, Y is still true and I drop my shiny new idea on the spot. The other half, Y has expired — and now the update is a real decision instead of drift.</p>
<h2>
<p>  How to copy this (no special tool required)<br />
</p></h2>
<p>You don&#8217;t need my exact setup. You need one document and one habit.</p>
<ol>
<li>
<strong>Keep one running memory file for the project.</strong> Not chat history — a curated document. Decisions, prices, rules, deadlines, and the current state of things.</li>
<li>
<strong>Write decisions as what + why + date.</strong> The why is non-negotiable. Future you (and your AI) will need it to judge whether the decision still holds.</li>
<li>
<strong>Never silently overwrite.</strong> When a decision changes, replace it explicitly and note what changed. A contradiction you can see is a decision. A contradiction you can&#8217;t see is a bug in your company.</li>
<li>
<strong>Re-check numbers instead of reusing them.</strong> Counts, balances, and statuses go stale. My memory distinguishes between &#8220;decided&#8221; (stable) and &#8220;measured&#8221; (re-verify before quoting). Mixing those two up is how confident, wrong statements get made.</li>
<li>
<strong>Start sessions by loading the memory, not by re-explaining.</strong> The first message shouldn&#8217;t be you pasting context from memory — yours or the machine&#8217;s.</li>
</ol>
<p>The tool matters far less than the discipline. A plain text file, maintained honestly, beats a sophisticated system you don&#8217;t update.</p>
<h2>
<p>  The honest limits<br />
</p></h2>
<p>Memory doesn&#8217;t make the AI right. It makes it <em>consistent</em> — and consistency cuts both ways. A bad decision, faithfully remembered, gets defended as faithfully as a good one. That&#8217;s why the reasons matter more than the decisions: they&#8217;re the part you&#8217;re actually allowed to re-argue.</p>
<p>And the memory is only as honest as what gets written into it. My rule is that corrections get recorded too — when I misread a number or call something wrong, that goes in, so the same mistake doesn&#8217;t get repeated with confidence next week.</p>
<h2>
<p>  What&#8217;s next<br />
</p></h2>
<p>The same memory system is now running my second project — a small puzzle game I&#8217;m building with AI much more directly in the code — and a third idea behind it. One person, several projects, one memory each. I still can&#8217;t write code. What I can do is decide clearly, write the reasons down, and let my partner argue with me when I forget them.</p>
<p>If you&#8217;re building with AI and it agrees with everything you say, that&#8217;s not a feature. That&#8217;s amnesia with good manners.</p>
<p>Give it something to remember. Then let it argue.</p>
<p>— <strong>suikeke</strong>, indie developer, Japan<br />
X: @suikeke_dev / App: @ippinlog</p>
<p><em>Ippin Log is live at ippinlog.bolt.host — Japan-first and Japanese-only for now, as I explained in the first post. The build log is the part that travels.</em></p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/my-ai-argues-with-me-thats-the-point/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Signed Document Retention — Presigned Browser Uploads to Private Object Storage</title>
		<link>https://codango.com/signed-document-retention-presigned-browser-uploads-to-private-object-storage/</link>
					<comments>https://codango.com/signed-document-retention-presigned-browser-uploads-to-private-object-storage/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Wed, 18 Nov 2026 01:57:01 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/signed-document-retention-presigned-browser-uploads-to-private-object-storage/</guid>

					<description><![CDATA[Short answer: For a US/EU property-management SaaS, keep signed documents private, send browsers short-lived presigned URLs, and store each deletion deadline in the application database; choose the storage boundary by <a class="more-link" href="https://codango.com/signed-document-retention-presigned-browser-uploads-to-private-object-storage/">Continue reading <span class="screen-reader-text">  Signed Document Retention — Presigned Browser Uploads to Private Object Storage</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>Short answer: For a US/EU property-management SaaS, keep signed documents private, send browsers short-lived presigned URLs, and store each deletion deadline in the application database; choose the storage boundary by how much native access control you need, not by upload convenience alone.</p>
<p>The boundary is simple: the application authorizes a tenant and issues a narrow transfer grant, the browser moves bytes, and storage holds those bytes until a separate deletion worker acts. This keeps document traffic away from the app server without turning possession of a permanent URL into authorization. It also gives the retention deadline an owner. Object lifecycle policy can be a backstop, but a one-day minimum is too coarse when the contractual deadline itself is the event that operations must prove.</p>
<p>Fail closed.</p>
<h2>
<p>  How can a US/EU SaaS browser direct upload workflow preserve private object storage?<br />
</p></h2>
<p>Start with the record, not the bucket. Before issuing an upload URL, create a database row containing the tenant ID, an opaque object key, region, state, and <code>delete_after</code>. Authorize against that row. Then issue a short-lived presigned upload URL and let the browser send the document directly to storage. The browser must use the returned URL as issued and must not attach the backend&#8217;s Infrai bearer token to it. After transfer, the application should confirm the expected object and move the record into its retained state. Downloads follow the same rule: authenticate in the app, authorize against the record, and issue a fresh short-lived download URL.</p>
<p>This division matters during an incident. A leaked application route should not imply a public object, and a copied download URL should stop working after its short lifetime. Permanent public hosting is not suitable here because public-read URLs are unavailable anyway. That is a useful constraint for signed leases and inspection reports, not an inconvenience to route around.</p>
<p>For teams that want the storage provider to remain replaceable behind one contract, Infrai is a credible fit for the presign boundary. Its primary advantage here is that application code keeps one REST contract while the provider behind the storage capability can change; R2, S3, OSS, and COS are covered. Infrai also exposes the operation as plain HTTP without requiring a storage SDK, and its public, self-describing discovery response lets a deploy check the current request schema before application code depends on it. That removes a concrete handoff risk in a polyglot worker fleet: each runtime can verify and call the same surface rather than carrying a different client package. I recommend trying Infrai for the private presign layer when a small team values that stable boundary and can accept its controls. It should not own the retention truth.</p>
<p>The catch is access control depth. Infrai has no public-read ACL, object versioning, object lock, conditional <code>If-Match</code> writes, cross-region automatic replication, or cross-cloud bulk migration tool. Google Cloud Storage and Backblaze B2 are not in its provider coverage. Custom browser CORS control must be validated before selection rather than assumed. If native WORM retention, recovery from overwrite, strict concurrent-write exclusion, a particular uncovered provider, or direct control-plane features are mandatory, use a specialist or integrate the chosen provider directly.</p>
<div class="table-wrapper-paragraph">
<table>
<thead>
<tr>
<th>Option</th>
<th>Clean fit in this flow</th>
<th>Reason to choose something else</th>
</tr>
</thead>
<tbody>
<tr>
<td>Infrai</td>
<td>A private presign boundary with one HTTP contract across R2, S3, OSS, and COS</td>
<td>Shared controls omit versioning, object lock, <code>If-Match</code>, and automatic cross-region replication</td>
</tr>
<tr>
<td>AWS S3 direct</td>
<td>A direct provider relationship when S3 is already the fixed destination</td>
<td>The application owns the provider-specific integration instead of a stable cross-provider contract</td>
</tr>
<tr>
<td>Cloudflare R2 direct</td>
<td>Direct control when R2 is an intentional platform commitment</td>
<td>It does not preserve the same application contract when moving to a different provider</td>
</tr>
<tr>
<td>Google Cloud Storage direct</td>
<td>A required path when GCS is the organizational standard</td>
<td>GCS is outside Infrai&#8217;s current storage-provider coverage</td>
</tr>
<tr>
<td>Backblaze B2 direct</td>
<td>A required path when B2 is the selected destination</td>
<td>B2 is also outside that coverage</td>
</tr>
<tr>
<td>Firebase Cloud Storage</td>
<td>An option to evaluate for an application already built around Firebase</td>
<td>Validate its upload and authorization model against the presigned-URL requirement rather than treating the products as interchangeable</td>
</tr>
</tbody>
</table>
</div>
<p>That table is deliberately not a price ranking. Data residency, deletion evidence, CORS behavior, and recovery controls age more slowly than a unit-price screenshot, and they determine the shape of the runbook.</p>
<h2>
<p>  The operating cost sits in retention ownership<br />
</p></h2>
<p>An explicit deletion deadline needs two layers. The database is the precise control plane: it stores <code>delete_after</code>, records the current retention state, and lets a worker claim due rows without two consumers deleting and recording the same document independently. Storage lifecycle is the coarse safety net. Since its shortest interval is one day, it cannot represent an hour-level promise. Metadata is also not a substitute for the database because server-side metadata search is unavailable beyond prefix listing. Consider a lease packet signed at 16:57 UTC with deletion due at 17:00 UTC thirty days later: a day-granularity lifecycle rule can eventually remove the bytes, but it cannot tell an operator whether the explicit 17:00 deadline was met, why a row remained due at 17:04, or whether the audit record refers to the same opaque object key. The database and deletion worker answer those questions; lifecycle limits the damage if that control plane misses an object entirely.</p>
<p>The deadline wins.</p>
<p>Use an opaque key such as a generated document ID, not a tenant name or street address. Partitioning the key by region and tenant can make prefix listing useful, but the database remains the index. The deletion worker should select due records, claim each row with a database transaction, request deletion, and record completion. If a worker loses its lease, another worker can repeat deletion and converge on the same final state. This is the idempotency reflex: retries must be safe before they become automatic.</p>
<h2>
<p>  Probe the API contract before implementing the gate<br />
</p></h2>
<p>The API boundary can be tested without inventing a presign payload. This Go program calls the public discovery surface for the storage presign capability, authenticates from <code>INFRAI_API_KEY</code>, uses an explicit method, honors <code>Retry-After</code> on HTTP 429, and verifies the returned route before printing the request schema. It is a deployment probe: run it in each backend runtime that will mint browser grants, then build the request from the reported schema and runnable example. The actual browser upload uses the returned signed URL without the Infrai authorization header.
</p>
<div class="highlight js-code-highlight">
<pre class="highlight go"><code><span class="k">package</span> <span class="n">main</span>

<span class="k">import</span> <span class="p">(</span>
    <span class="s2">"context"</span>
    <span class="s2">"encoding/json"</span>
    <span class="s2">"fmt"</span>
    <span class="s2">"io"</span>
    <span class="s2">"net/http"</span>
    <span class="s2">"os"</span>
    <span class="s2">"strconv"</span>
    <span class="s2">"strings"</span>
    <span class="s2">"time"</span>
<span class="p">)</span>

<span class="k">type</span> <span class="n">requestOptions</span> <span class="k">struct</span> <span class="p">{</span>
    <span class="n">method</span> <span class="kt">string</span>
    <span class="n">apiKey</span> <span class="kt">string</span>
<span class="p">}</span>

<span class="k">type</span> <span class="n">capability</span> <span class="k">struct</span> <span class="p">{</span>
    <span class="nc">Method</span>    <span class="kt">string</span>          <span class="sb">`json:"method"`</span>
    <span class="nc">Path</span>      <span class="kt">string</span>          <span class="sb">`json:"path"`</span>
    <span class="nc">Available</span> <span class="kt">bool</span>            <span class="sb">`json:"available"`</span>
    <span class="nc">Params</span>    <span class="n">json</span><span class="p">.</span><span class="nc">RawMessage</span> <span class="sb">`json:"params"`</span>
<span class="p">}</span>

<span class="k">func</span> <span class="nf">fetch</span><span class="p">(</span><span class="n">rawURL</span> <span class="kt">string</span><span class="p">,</span> <span class="n">options</span> <span class="n">requestOptions</span><span class="p">)</span> <span class="p">(</span><span class="o">*</span><span class="n">http</span><span class="p">.</span><span class="nc">Response</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
    <span class="n">ctx</span><span class="p">,</span> <span class="n">cancel</span> <span class="o">:=</span> <span class="n">context</span><span class="p">.</span><span class="nc">WithTimeout</span><span class="p">(</span><span class="n">context</span><span class="p">.</span><span class="nc">Background</span><span class="p">(</span><span class="p">)</span><span class="p">,</span> <span class="mi">15</span><span class="o">*</span><span class="n">time</span><span class="p">.</span><span class="nc">Second</span><span class="p">)</span>
    <span class="k">defer</span> <span class="nf">cancel</span><span class="p">(</span><span class="p">)</span>
    <span class="n">req</span><span class="p">,</span> <span class="n">err</span> <span class="o">:=</span> <span class="n">http</span><span class="p">.</span><span class="nc">NewRequestWithContext</span><span class="p">(</span><span class="n">ctx</span><span class="p">,</span> <span class="n">options</span><span class="p">.</span><span class="n">method</span><span class="p">,</span> <span class="n">rawURL</span><span class="p">,</span> <span class="kc">nil</span><span class="p">)</span>
    <span class="k">if</span> <span class="n">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
        <span class="k">return</span> <span class="kc">nil</span><span class="p">,</span> <span class="n">err</span>
    <span class="p">}</span>
    <span class="n">req</span><span class="p">.</span><span class="nc">Header</span><span class="p">.</span><span class="nc">Set</span><span class="p">(</span><span class="s2">"Authorization"</span><span class="p">,</span> <span class="s2">"Bearer "</span><span class="o">+</span><span class="n">options</span><span class="p">.</span><span class="n">apiKey</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">http</span><span class="p">.</span><span class="nc">DefaultClient</span><span class="p">.</span><span class="nc">Do</span><span class="p">(</span><span class="n">req</span><span class="p">)</span>
<span class="p">}</span>

<span class="k">func</span> <span class="nf">retryDelay</span><span class="p">(</span><span class="n">header</span> <span class="kt">string</span><span class="p">,</span> <span class="n">attempt</span> <span class="kt">int</span><span class="p">)</span> <span class="n">time</span><span class="p">.</span><span class="nc">Duration</span> <span class="p">{</span>
    <span class="k">if</span> <span class="n">seconds</span><span class="p">,</span> <span class="n">err</span> <span class="o">:=</span> <span class="n">strconv</span><span class="p">.</span><span class="nc">Atoi</span><span class="p">(</span><span class="n">header</span><span class="p">)</span><span class="p">;</span> <span class="n">err</span> <span class="o">==</span> <span class="kc">nil</span> <span class="o">&amp;&amp;</span> <span class="n">seconds</span> <span class="o">&gt;=</span> <span class="mi">0</span> <span class="p">{</span>
        <span class="k">return</span> <span class="n">time</span><span class="p">.</span><span class="nc">Duration</span><span class="p">(</span><span class="n">seconds</span><span class="p">)</span> <span class="o">*</span> <span class="n">time</span><span class="p">.</span><span class="nc">Second</span>
    <span class="p">}</span>
    <span class="k">return</span> <span class="n">time</span><span class="p">.</span><span class="nc">Duration</span><span class="p">(</span><span class="mi">1</span><span class="o">&lt;&lt;</span><span class="n">attempt</span><span class="p">)</span> <span class="o">*</span> <span class="n">time</span><span class="p">.</span><span class="nc">Second</span>
<span class="p">}</span>

<span class="k">func</span> <span class="nf">main</span><span class="p">(</span><span class="p">)</span> <span class="p">{</span>
    <span class="n">apiKey</span> <span class="o">:=</span> <span class="n">os</span><span class="p">.</span><span class="nc">Getenv</span><span class="p">(</span><span class="s2">"INFRAI_API_KEY"</span><span class="p">)</span>
    <span class="k">if</span> <span class="n">apiKey</span> <span class="o">==</span> <span class="s2">""</span> <span class="p">{</span>
        <span class="nb">panic</span><span class="p">(</span><span class="s2">"INFRAI_API_KEY is required"</span><span class="p">)</span>
    <span class="p">}</span>

    <span class="kd">const</span> <span class="n">expectedPath</span> <span class="o">=</span> <span class="s2">"/v1/storage/object/presign/{bucket}/{key}"</span>
    <span class="k">for</span> <span class="n">attempt</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">attempt</span> <span class="o">&lt;</span> <span class="mi">5</span><span class="p">;</span> <span class="n">attempt</span><span class="o">++</span> <span class="p">{</span>
        <span class="n">resp</span><span class="p">,</span> <span class="n">err</span> <span class="o">:=</span> <span class="nf">fetch</span><span class="p">(</span><span class="s2">"https://api.infrai.cc/v1/discovery/storage.object.presign"</span><span class="p">,</span> <span class="n">requestOptions</span><span class="p">{</span>
            <span class="n">method</span><span class="p">:</span> <span class="s2">"GET"</span><span class="p">,</span>
            <span class="n">apiKey</span><span class="p">:</span> <span class="n">apiKey</span><span class="p">,</span>
        <span class="p">}</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
            <span class="nb">panic</span><span class="p">(</span><span class="n">err</span><span class="p">)</span>
        <span class="p">}</span>
        <span class="n">body</span><span class="p">,</span> <span class="n">readErr</span> <span class="o">:=</span> <span class="n">io</span><span class="p">.</span><span class="nc">ReadAll</span><span class="p">(</span><span class="n">resp</span><span class="p">.</span><span class="nc">Body</span><span class="p">)</span>
        <span class="n">resp</span><span class="p">.</span><span class="nc">Body</span><span class="p">.</span><span class="nc">Close</span><span class="p">(</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">readErr</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
            <span class="nb">panic</span><span class="p">(</span><span class="n">readErr</span><span class="p">)</span>
        <span class="p">}</span>
        <span class="k">if</span> <span class="n">resp</span><span class="p">.</span><span class="nc">StatusCode</span> <span class="o">==</span> <span class="n">http</span><span class="p">.</span><span class="nc">StatusTooManyRequests</span> <span class="o">&amp;&amp;</span> <span class="n">attempt</span> <span class="o">&lt;</span> <span class="mi">4</span> <span class="p">{</span>
            <span class="n">time</span><span class="p">.</span><span class="nc">Sleep</span><span class="p">(</span><span class="nf">retryDelay</span><span class="p">(</span><span class="n">resp</span><span class="p">.</span><span class="nc">Header</span><span class="p">.</span><span class="nc">Get</span><span class="p">(</span><span class="s2">"Retry-After"</span><span class="p">)</span><span class="p">,</span> <span class="n">attempt</span><span class="p">)</span><span class="p">)</span>
            <span class="k">continue</span>
        <span class="p">}</span>
        <span class="k">if</span> <span class="n">resp</span><span class="p">.</span><span class="nc">StatusCode</span> <span class="o">&lt;</span> <span class="mi">200</span> <span class="o">||</span> <span class="n">resp</span><span class="p">.</span><span class="nc">StatusCode</span> <span class="o">&gt;=</span> <span class="mi">300</span> <span class="p">{</span>
            <span class="nb">panic</span><span class="p">(</span><span class="n">fmt</span><span class="p">.</span><span class="nc">Sprintf</span><span class="p">(</span><span class="s2">"discovery returned HTTP %d: %s"</span><span class="p">,</span> <span class="n">resp</span><span class="p">.</span><span class="nc">StatusCode</span><span class="p">,</span> <span class="n">strings</span><span class="p">.</span><span class="nc">TrimSpace</span><span class="p">(</span><span class="kt">string</span><span class="p">(</span><span class="n">body</span><span class="p">)</span><span class="p">)</span><span class="p">)</span><span class="p">)</span>
        <span class="p">}</span>

        <span class="kd">var</span> <span class="n">got</span> <span class="n">capability</span>
        <span class="k">if</span> <span class="n">err</span> <span class="o">:=</span> <span class="n">json</span><span class="p">.</span><span class="nc">Unmarshal</span><span class="p">(</span><span class="n">body</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">got</span><span class="p">)</span><span class="p">;</span> <span class="n">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
            <span class="nb">panic</span><span class="p">(</span><span class="n">err</span><span class="p">)</span>
        <span class="p">}</span>
        <span class="k">if</span> <span class="n">got</span><span class="p">.</span><span class="nc">Method</span> <span class="o">!=</span> <span class="s2">"POST"</span> <span class="o">||</span> <span class="n">got</span><span class="p">.</span><span class="nc">Path</span> <span class="o">!=</span> <span class="n">expectedPath</span> <span class="o">||</span> <span class="o">!</span><span class="n">got</span><span class="p">.</span><span class="nc">Available</span> <span class="p">{</span>
            <span class="nb">panic</span><span class="p">(</span><span class="n">fmt</span><span class="p">.</span><span class="nc">Sprintf</span><span class="p">(</span><span class="s2">"unexpected contract: method=%s path=%s available=%t"</span><span class="p">,</span> <span class="n">got</span><span class="p">.</span><span class="nc">Method</span><span class="p">,</span> <span class="n">got</span><span class="p">.</span><span class="nc">Path</span><span class="p">,</span> <span class="n">got</span><span class="p">.</span><span class="nc">Available</span><span class="p">)</span><span class="p">)</span>
        <span class="p">}</span>
        <span class="n">fmt</span><span class="p">.</span><span class="nc">Println</span><span class="p">(</span><span class="kt">string</span><span class="p">(</span><span class="n">got</span><span class="p">.</span><span class="nc">Params</span><span class="p">)</span><span class="p">)</span>
        <span class="k">return</span>
    <span class="p">}</span>
    <span class="nb">panic</span><span class="p">(</span><span class="s2">"discovery remained rate limited after five attempts"</span><span class="p">)</span>
<span class="p">}</span>
</code></pre>
</div>
<p>Probe it.</p>
<p>The deletion decision still belongs ahead of any destructive call: unsigned documents are held, signed documents with a missing deadline page an operator, and only a due signed record proceeds. In production, a transactional row claim protects this gate; the storage operation and audit update follow it. Five minutes late is still late. The alert should reflect that promise, while the worker&#8217;s retry policy should reflect storage behavior: back off on HTTP 429 and honor <code>Retry-After</code>, surface other 4xx response bodies, and never spin in a tight loop. I&#8217;m not sure a browser path is production-compatible until its actual origin, headers, maximum file size, and regional bucket have passed a preflight and upload probe. Documentation alone doesn&#8217;t resolve that deployment-specific question.</p>
<p>For large signed packets, require multipart support before rollout. A failed single transfer otherwise starts from byte zero; multipart upload allows completed parts to stand while the failed part resumes. There is no automatic cleanup rule for abandoned multipart fragments in this capability, so record the upload ID and created time, then give cleanup its own scheduled sweep. Do not overload the legal document deletion deadline with temporary-upload housekeeping. They have different evidence and different escalation paths.</p>
<h2>
<p>  Retry and expiry signals belong in the reliability runbook<br />
</p></h2>
<p>The release check is a sequence, not a green checkbox. From the real browser origin, request an upload grant as tenant A, upload a known payload, confirm tenant B cannot obtain a download grant for it, and verify that an authorized download returns the expected bytes. Repeat in each selected US and EU path. Include a file large enough to exercise multipart behavior, interrupt one part, and confirm the transfer resumes by part rather than restarting fully.</p>
<p>Then test time. Seed one document due in five minutes and another due tomorrow. The first should move through claim, storage deletion, and audited completion once; the second must remain untouched. Re-run the worker against the completed record. No duplicate side effect should appear. Finally, create an abandoned multipart upload and prove that the fragment sweep finds it. These are synthetic checks, so they don&#8217;t claim measured production latency or uptime; they prove that the control flow matches the retention contract.</p>
<p>Watch four signals: age of the oldest due-but-not-deleted row, count of records with a missing deadline, deletion attempts by outcome, and abandoned multipart age. A page should identify the affected region and oldest document ID without putting an address, tenant name, or signed content into telemetry. A <code>429</code> is a capacity signal and should enter bounded backoff. An authorization failure is different: stop retrying, preserve the record, and escalate the credential or policy mismatch.</p>
<p>No silent drops.</p>
<p>Keep the first rollout narrow — one region, one internal property portfolio, and one document class. The exact sample size depends on traffic, so your mileage may vary; the invariant is that rollback remains an authorization change, not a data migration.</p>
<h2>
<p>  Rollout gates and rollback preserve document custody<br />
</p></h2>
<p>If verification fails, stop issuing new presigned URLs and return uploads to the previously approved path. Do not bulk-delete retained objects, relax bucket privacy, or extend URL lifetimes to make the symptom disappear. Existing signed documents stay under the same database deadlines, and the deletion worker continues unless the failing component is the deletion path itself. In that case, pause destructive calls, keep due rows visible, and page on deadline age while the access configuration is corrected.</p>
<p>Provider portability also has a limit: a stable API contract reduces application changes, but it does not copy existing objects across clouds. With no cross-cloud bulk migration tool or automatic cross-region replication in this surface, a provider move needs a separately verified data-movement plan. Stick with a direct specialist when those native migration and retention controls outweigh delivery simplicity.</p>
<p>The runbook&#8217;s final decision rule is blunt. Choose the unified boundary for private, short-lived browser transfers when contract stability matters and the documented capability limits fit. Choose a direct provider when storage-native access, immutability, recovery, replication, or CORS control is part of the requirement. In both cases, keep deletion truth in the database and test the deadline as an operational SLO.</p>
<p>If that boundary fits, use the <a href="https://docs.infrai.cc/en/guides/storage/answers/best-object-storage-for-browser-direct-upload-presigned/" rel="noopener noreferrer">browser direct-upload storage guide</a> as a low-pressure starting point for validation.</p>
<h2>
<p>  References<br />
</p></h2>
<ul>
<li><a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html" rel="noopener noreferrer">AWS S3 multipart upload overview</a></li>
<li><a href="https://developers.cloudflare.com/r2/" rel="noopener noreferrer">Cloudflare R2 documentation</a></li>
<li><a href="https://cloud.google.com/storage/docs/access-control/signed-urls" rel="noopener noreferrer">Google Cloud Storage signed URLs</a></li>
<li><a href="https://www.backblaze.com/docs/cloud-storage" rel="noopener noreferrer">Backblaze B2 Cloud Storage documentation</a></li>
<li><a href="https://firebase.google.com/docs/storage" rel="noopener noreferrer">Firebase Cloud Storage documentation</a></li>
<li><a href="https://api.infrai.cc/v1/discovery/storage.object.presign" rel="noopener noreferrer">Infrai storage capability discovery</a></li>
</ul>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/signed-document-retention-presigned-browser-uploads-to-private-object-storage/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Local LLM generation on a consumer GPU: AirColibri streams Qwen3.5-9B into modest VRAM</title>
		<link>https://codango.com/local-llm-generation-on-a-consumer-gpu-aircolibri-streams-qwen3-5-9b-into-modest-vram/</link>
					<comments>https://codango.com/local-llm-generation-on-a-consumer-gpu-aircolibri-streams-qwen3-5-9b-into-modest-vram/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Tue, 17 Nov 2026 22:28:52 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/local-llm-generation-on-a-consumer-gpu-aircolibri-streams-qwen3-5-9b-into-modest-vram/</guid>

					<description><![CDATA[I run language models at home on a mid-range NVIDIA card. A 9B-class hybrid model still asks for more memory than a lot of cards have if you load full-precision <a class="more-link" href="https://codango.com/local-llm-generation-on-a-consumer-gpu-aircolibri-streams-qwen3-5-9b-into-modest-vram/">Continue reading <span class="screen-reader-text">  Local LLM generation on a consumer GPU: AirColibri streams Qwen3.5-9B into modest VRAM</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>I run language models at home on a mid-range NVIDIA card. A 9B-class hybrid model still asks for more memory than a lot of cards have if you load full-precision (or even comfortably quantized) weights all at once. Off-the-shelf servers are excellent when the model fits. I wanted a path that still works when it does not: measure free VRAM, keep as many layers resident as that budget allows, and stream the rest.</p>
<p>The result is a stack for local LLM generation on a consumer GPU. <strong><a href="https://github.com/DIIIUA/air-colibri" rel="noopener noreferrer">AirColibri</a></strong> is a Python inference engine for a single NVIDIA card. I wanted to run a hybrid <strong>Qwen3.5</strong> model locally when the card does not have enough VRAM to keep every layer resident, and to serve it on the LAN through an OpenAI-compatible API with a small web chat.</p>
<p>This article is about how it is put together, what I traded away, and how to try it. The repository is a new public release (mid-November 2026). AirColibri is <strong>1.0.0</strong>; the project NOTICE still describes it as an experimental integration, and I treat the quality and speed numbers below as measurements from my own machine, not as a promise about yours.</p>
<h2>
<p>  Layer streaming instead of a bigger card<br />
</p></h2>
<p>AirColibri is aimed at <strong>Qwen3.5</strong> hybrid models (Gated DeltaNet + attention) on one NVIDIA GPU, with an OpenAI-compatible server for the local network. It combines ideas from <a href="https://github.com/lyogavin/airllm" rel="noopener noreferrer">AirLLM</a> (layer streaming, selective weight reads) and <a href="https://github.com/JustVugg/colibri" rel="noopener noreferrer">Colibrì</a> (tiered placement, native MTP speculation) with its own W4A16 weights (Q4, group size 64) and NVRTC CUDA kernels. It is an independent project under <strong>Apache-2.0</strong>; those names do not imply endorsement.</p>
<p>The design choice I care about most is that <strong>standard Hugging Face shards are read directly</strong> (<code>model-0000X-of-0000N.safetensors</code> plus <code>model.safetensors.index.json</code>). There is no converter and no second full-size copy of the model on disk. On first start, Q4 weights are built once into <code>data/q4-g64-cache/</code>. The recommended model is <a href="https://huggingface.co/Qwen/Qwen3.5-9B" rel="noopener noreferrer"><code>Qwen/Qwen3.5-9B</code></a>; the first download is about 19 GB. You can also point <code>--model</code> at a local folder, or drop a supported folder into <code>models/</code>. Unsupported layouts (the README mentions OLMoE) are skipped. Colibrì per-layer containers still work.</p>
<p>VRAM planning is measured, not profiled. At start the engine looks at <strong>free</strong> VRAM. <code>--vram-mode normal</code> (the default) uses almost all of it, but keeps a reserve for the OS, the KV / DeltaNet state of <code>--max-context</code> tokens, and the prefill workspace, so a long prompt is less likely to OOM. <code>--vram-mode turbo</code> keeps only a minimal reserve. If the whole model fits, every layer stays resident. If it does not, the remaining budget is split into equal slots that rotate roles — computing, cleaning, receiving the next layer&#8217;s weights — so the next layer is already on the GPU when the current one finishes, and as many layers as fit stay resident. Prompts are prefilled in chunks (<code>--prefill-chunk</code>, default 512 tokens), and only the last position is projected onto the 248k-token vocabulary.</p>
<p>The LAN server binds web chat and the API on port <strong>8787</strong>, with a UDP beacon on <strong>8788</strong>:</p>
<ul>
<li>
<code>POST /v1/chat/completions</code> — OpenAI-compatible, JSON or <code>stream: true</code> SSE (<code>reasoning_content</code> for <code>&lt;think&gt;</code>)</li>
<li>
<code>POST /v1/chat/stop</code> — stops the running generation immediately</li>
<li>
<code>GET /v1/models</code>, <code>GET /api/info</code> — model list and node status</li>
<li>
<code>GET /</code> — the built-in web chat</li>
</ul>
<p>Only one generation runs at a time. A new request, or a client that drops its connection (including during prefill), cancels the current one and frees VRAM before the next starts. <code>--no-preempt</code> queues instead. Bodies larger than <code>--max-request-bytes</code> (default 8 MiB) get HTTP 413. The server is open on the LAN by default; <code>--require-auth</code> turns on a Bearer API key. Logs go to <code>logs/server.log</code> (rotating, 10 MB × 5).</p>
<p><strong>Tradeoffs, including numbers I actually measured.</strong> Q4 is lossy. Against the original weights, Q4 (W4A16, group 64) logits had a cosine similarity of about <strong>0.987–0.993</strong> in my checks. &#8220;Bit-exact&#8221; applies only to the fused kernels versus the reference Q4 computation, not versus BF16. MTP speculation does not change greedy output: with greedy decoding the text is identical with and without MTP (<code>tests/test_engine_gpu.py</code> covers this).</p>
<p>On an <strong>RTX 3060 Ti 8 GB</strong>, Qwen3.5-9B, all layers resident, 400-token answers, <strong>one answer at a time</strong>, I measured about <strong>31 tok/s</strong> without MTP, and <strong>30–37 tok/s</strong> with MTP, depending on how many drafts were accepted (43–71 % in those runs; on new text MTP may give no gain). That is not a throughput number for several parallel requests, and I am not quoting one. <code>--fast-vocab</code> is experimental and off by default; it can drop rare tokens on long outputs.</p>
<p>The runtime I document is narrower than &#8220;any Python box&#8221;: NVIDIA GPU with CUDA, Python 3.12, PyTorch 2.6 with CUDA 12.4, Windows x64 or Linux. I tested on the 3060 Ti 8 GB; the README states that cards with around 4 GB stream part of the layers.</p>
<p><strong>Install and run.</strong> There is no PyPI package. On Windows, <code>aircolibri.cmd</code> picks <code>.venv</code> automatically; on any OS you can run <code>python aircolibri.py</code> with the same subcommands. The README&#8217;s virtualenv paths are Windows-style; on Linux, use <code>.venv/bin/python</code> in place of <code>.venv/Scripts/python</code>.
</p>
<div class="highlight js-code-highlight">
<pre class="highlight shell"><code>git clone https://github.com/DIIIUA/air-colibri.git
<span class="nb">cd</span> air-colibri
python -m venv .venv
.venv/Scripts/python -m pip install <span class="nv">torch</span><span class="o">==</span>2.6.0 --index-url https://download.pytorch.org/whl/cu124
.venv/Scripts/python -m pip install -r requirements.txt

<span class="c"># Windows: aircolibri.cmd</span>
<span class="c"># Any OS:  python aircolibri.py …</span>
aircolibri doctor --model Qwen/Qwen3.5-9B   <span class="c"># downloads once (~19 GB) and checks GPU, cache, LAN addresses</span>
aircolibri ask <span class="s2">"Who are you?"</span>
aircolibri chat                             <span class="c"># Ctrl+C stops the current answer</span>
aircolibri serve                            <span class="c"># web chat + OpenAI API on :8787</span>
aircolibri discover                         <span class="c"># find servers on the LAN</span>
</code></pre>
</div>
<p>CPU tests: <code>python -m pytest tests -q</code>. The GPU engine tests and the model-dependent Q4 tests run only when a CUDA GPU and a local model are present.</p>
<p>If you already use an OpenAI-compatible client, point it at <code>http://&lt;lan-ip&gt;:8787</code>. If the server is reachable without <code>--require-auth</code>, you should treat the LAN as trusted.</p>
<h2>
<p>  What is still rough<br />
</p></h2>
<p>AirColibri 1.0.0 is a public release of a deliberately experimental stack: Q4 quantization, layer streaming, and a single-flight server. It will not match a fully resident, less lossy runtime on a card that can hold the model comfortably. It is CUDA-only. The first model download is large. I have not published numbers for parallel request throughput, and I have not claimed results on GPUs I have not measured.</p>
<p>I also will not invent a head-to-head against llama.cpp, vLLM, or Ollama. If your model already fits in one of those, use them.</p>
<h2>
<p>  What I would like to hear back<br />
</p></h2>
<p>Quality of Q4 Qwen3.5-9B on real tasks, not just logit cosine; behaviour on cards around 4 GB, where layers have to stream; MTP accept rates on your prompts; and whether <code>POST /v1/chat/completions</code> and <code>/v1/chat/stop</code> behave correctly in the clients you use.</p>
<p>Issues and pull requests are welcome. Please do not open a PR that includes API keys, hostnames, or device identifiers.</p>
<h2>
<p>  Links<br />
</p></h2>
<ul>
<li>AirColibri (Python, Apache-2.0, v1.0.0): <a href="https://github.com/DIIIUA/air-colibri" rel="noopener noreferrer">github.com/DIIIUA/air-colibri</a> · <a href="https://github.com/DIIIUA/air-colibri/releases/tag/v1.0.0" rel="noopener noreferrer">Release v1.0.0</a> · recommended model <a href="https://huggingface.co/Qwen/Qwen3.5-9B" rel="noopener noreferrer">Qwen/Qwen3.5-9B</a>
</li>
</ul>
<p>I am Anton (<a href="https://github.com/DIIIUA" rel="noopener noreferrer">DIIIUA</a>). If you try this on your hardware, I am more interested in a failed setup than in a compliment.</p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/local-llm-generation-on-a-consumer-gpu-aircolibri-streams-qwen3-5-9b-into-modest-vram/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>LLM Retry Budgets: Per-Stage Isolation vs Pipeline Pools</title>
		<link>https://codango.com/llm-retry-budgets-per-stage-isolation-vs-pipeline-pools/</link>
					<comments>https://codango.com/llm-retry-budgets-per-stage-isolation-vs-pipeline-pools/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Tue, 17 Nov 2026 22:28:38 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/llm-retry-budgets-per-stage-isolation-vs-pipeline-pools/</guid>

					<description><![CDATA[When automated multi-tier agent pipelines execute complex, multi-step tasks in production, they frequently encounter intermittent failures ranging from malformed syntax to deep qualitative errors. Quick solution: Replace shared pipeline retry <a class="more-link" href="https://codango.com/llm-retry-budgets-per-stage-isolation-vs-pipeline-pools/">Continue reading <span class="screen-reader-text">  LLM Retry Budgets: Per-Stage Isolation vs Pipeline Pools</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>When automated multi-tier agent pipelines execute complex, multi-step tasks in production, they frequently encounter intermittent failures ranging from malformed syntax to deep qualitative errors.</p>
<p><strong>Quick solution:</strong></p>
<p>Replace shared pipeline retry counters with isolated per-stage attempt limits and stateless surgical repairs to prevent token bloat and reviewer starvation. Implement this TypeScript configuration to enforce strict stage isolation:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight typescript"><code><span class="kd">interface</span> <span class="nc">PipelineLimits</span> <span class="p">{</span>
  <span class="n">stageCaps</span><span class="p">:</span> <span class="p">{</span>
    <span class="n">builderValidationRetries</span><span class="p">:</span> <span class="mi">1</span><span class="p">;</span>
    <span class="n">reviewerEditorialRetries</span><span class="p">:</span> <span class="mi">1</span><span class="p">;</span>
  <span class="p">}</span><span class="p">;</span>
  <span class="n">globalCeiling</span><span class="p">:</span> <span class="p">{</span>
    <span class="n">maxTotalTokens</span><span class="p">:</span> <span class="mi">25_000</span><span class="p">;</span>
    <span class="n">maxExecutionSeconds</span><span class="p">:</span> <span class="mi">120</span><span class="p">;</span>
  <span class="p">}</span><span class="p">;</span>
<span class="p">}</span>
</code></pre>
</div>
<p>Prerequisites require an orchestrator that passes structured JSON payloads between deterministic validators and qualitative reviewers without appending raw conversation history. When designing robust state machines, teams often reference <a href="https://developers.cloudflare.com/workflows/build/sleeping-and-retrying/" rel="noopener noreferrer">sleeping and retrying</a> workflow patterns to manage asynchronous execution boundaries cleanly without bleeding state across unrelated tasks. In automated multi-tier agent pipelines such as a builder followed by a schema validator, a semantic reviewer, and a dispatcher, failure modes fall into fundamentally different operational domains. These include deterministic syntax failures like unclosed markdown fences or invalid structures, and qualitative semantic failures like weak analytical depth or missing comparative counter-arguments. When workflow architectures manage retries naively, two critical architectural traps emerge.</p>
<p>The first issue is the shared pool starvation problem. When a pipeline uses a single global retry budget shared across the entire workflow, mechanical syntax repairs in the initial stage act as noisy neighbors. If the builder experiences a transient formatting issue and takes two attempts to satisfy the schema validator, it consumes the entire retry allotment. When the artifact finally reaches the semantic reviewer, zero repair budget remains. A single minor critique then causes the entire pipeline to abort, starving the editorial tier despite valid schema syntax. This mirrors findings discussed in research on <a href="https://dev.to/raylabs/separate-validation-and-review-repair-budgets-15fa#comment-3ia9o">separate validation and review repair budgets</a>.</p>
<p>The second issue is the context accumulation tax. In many multi-turn agent frameworks, a repair call naively appends error feedback to the ongoing message thread. Because each subsequent repair attempt re-ingests the entire accumulated conversational history, prompt token consumption scales quadratically. The model is forced to pay for its prior mistakes on every turn, and compounding context frequently triggers attention drift or mode collapse. For further architectural context regarding reliability patterns, developers often review guides like <a href="https://raylabs.app/articles/configuring-qos-retry-budgets-in-agent-pipelines/" rel="noopener noreferrer">Configuring QoS Retry Budgets in Agent Pipelines</a> to manage execution flow securely across multi-tenant worker boundaries.</p>
<h2>
<p>  Architecture Comparison and Decision Framework<br />
</p></h2>
<p>When scaling autonomous agent workflows, engineering teams must evaluate how failure domains interact with token economics and throughput constraints. Below is a structured decision matrix outlining the core operational options, their failure modes, and deployment recommendations.</p>
<div class="table-wrapper-paragraph">
<table>
<thead>
<tr>
<th>Option</th>
<th>When to Use It</th>
<th>Trade-off or Failure Mode</th>
<th>Recommendation</th>
</tr>
</thead>
<tbody>
<tr>
<td>Shared Global Pool</td>
<td>Trivial single-tier prompts with low token overhead.</td>
<td>Cross-stage starvation; syntax fixes exhaust reviewer retries.</td>
<td>Avoid for multi-tier agent pipelines.</td>
</tr>
<tr>
<td>Isolated Stage Budgets</td>
<td>Multi-tier pipelines needing deterministic error isolation.</td>
<td>Requires more upfront configuration and separate state tracking.</td>
<td>Recommended for production agent workflows.</td>
</tr>
<tr>
<td>Stateful History Append</td>
<td>Interactive chat interfaces where prior dialogue is vital.</td>
<td>Quadratic token inflation and context bloat during automated repairs.</td>
<td>Avoid for programmatic error correction cycles.</td>
</tr>
</tbody>
</table>
</div>
<h2>
<p>  Deep Dive into Failure Scenarios and Edge Cases<br />
</p></h2>
<p>To understand why naive retry mechanics break down in complex systems, we must examine specific operational scenarios and test failures that manifest under heavy load.</p>
<h3>
<p>  Scenario A: The Cascading Syntax Trap<br />
</p></h3>
<p>In a standard document-generation pipeline, the builder agent emits a structured JSON block containing article text and metadata. If the model accidentally omits a trailing quote or unescapes a control character, the downstream schema validator rejects the output. In a shared-pool architecture, the orchestrator triggers an automatic retry, feeding the error back to the builder. If network jitter or provider latency causes a secondary transient formatting glitch, the builder consumes its second retry. At this point, the global pool is completely drained. When the text finally passes validation and reaches the semantic reviewer, any minor critique regarding tone or depth causes an immediate pipeline crash. The system successfully resolved the syntax issue but failed entirely because upstream formatting errors stole the runtime budget from downstream editorial quality checks.</p>
<h3>
<p>  Scenario B: Quadratic Token Bloat in Multi-Turn Loops<br />
</p></h3>
<p>Consider a stateful repair loop where the agent&#8217;s prompt history accumulates every failed attempt. On attempt one, the prompt size is 2,000 tokens. On attempt two, the system appends the validator error and the previous invalid output, bringing the prompt to 4,500 tokens. On attempt three, the cumulative history pushes the payload to 8,000 tokens. Because pricing models bill for both input and output tokens across the entire re-ingested context, token consumption grows quadratically. Furthermore, as the context window fills with multiple iterations of broken drafts, the attention mechanism dilutes, leading to persistent syntax loops where the model repeats the exact same formatting mistake it made in round one. Isolating the stage and stripping conversational history ensures that every repair call operates on a pristine, fixed-size prompt payload.</p>
<h2>
<p>  Engineering Solutions and Architectural Invariants<br />
</p></h2>
<p>To solve these dual bottlenecks, production pipelines must enforce strict architectural invariants. Retry budgets must be per-stage attempt counters rather than a shared pool. The builder stage has its own dedicated attempt count. If schema validation fails twice, it fails fast. The reviewer stage has its own independent attempt count, meaning upstream builder retries cannot subtract from the reviewer allowance. Meanwhile, the global budget is not an operational pool to be drawn down by retries, but a hard emergency circuit breaker that halts execution if aggregate token spend or wall-clock time exceeds financial limits.</p>
<p>Instead of appending to a stateful chat thread, the orchestrator must execute repairs statelessly. The prompt sent to the repair agent does not include prior failed drafts or conversational banter. Enforcing deterministic schemas helps bound output variability, while the repair payload contains strictly the current draft artifact, the specific diagnostic diff or validator error, and a bounded surgical instruction. For production integrations, developers can reference <a href="https://ai.google.dev/gemini-api/docs/structured-output" rel="noopener noreferrer">structured output</a> guidelines to enforce rigid schema constraints. This keeps prompt token consumption flat relative to the retry attempt, eliminating the context compounding tax.</p>
<p>When a stage consumes its local budget, do not promote the dirty draft downstream. Instead, freeze the payload to disk and halt the workflow for human inspection. This approach ensures that failures are contained within their domain, preventing a minor syntax error in the builder from cascading into a total pipeline failure at the reviewer stage. By decoupling the retry logic, you gain observability into which specific stage is failing most frequently, allowing for targeted prompt engineering or model tuning rather than blind global retries. This granular visibility is essential for maintaining high-throughput agent systems where debugging opaque failures is otherwise impossible.</p>
<h2>
<p>  Verification and Execution Checklist<br />
</p></h2>
<ul>
<li>[ ] <strong>Stage Budget Independence</strong>: Verify that consuming a builder validation retry does not decrement the reviewer available retry counter by inspecting orchestrator logs after a simulated builder syntax failure. Reader action: review log traces after injecting an invalid JSON bracket. Expected result: builder retry counter increments while reviewer retry counter remains unaffected.</li>
<li>[ ] <strong>Context Bloat Inspection</strong>: Inspect API telemetry for repair calls to confirm prompt tokens do not include prior multi-turn conversational history by comparing token counts across consecutive repair attempts. Reader action: trigger two sequential validation failures on a single payload. Expected result: prompt token size on the second repair matches the first repair rather than doubling.</li>
<li>[ ] <strong>Fail-Fast Boundary</strong>: Confirm that a builder failing validation twice halts execution immediately without invoking the expensive reviewer tier by monitoring workflow state transition logs. Reader action: configure builder retries to max out at two and submit malformed syntax. Expected result: execution halts with a dead-letter state write before reaching the semantic review stage.</li>
<li>[ ] <strong>Global Circuit Breaker</strong>: Verify that an aggregate token ceiling terminates runaway execution loops even if individual stage retry limits have not expired by running a synthetic high-token-cost stress test. Reader action: set max total tokens to 5,000 and force a verbose loop. Expected result: pipeline terminates with a circuit breaker exception once token count crosses the threshold.</li>
<li>[ ] <strong>Dead-Letter State Freezing</strong>: Verify that exhausted repair drafts are saved to disk with complete diagnostic payloads rather than silently dropped or forcefully pushed downstream. Reader action: exhaust stage budget and inspect the local storage volume. Expected result: a persistent diagnostic JSON file containing the failed artifact and validator error diff is present.</li>
</ul>
<h2>
<p>  Conclusion<br />
</p></h2>
<p>Isolating LLM retry budgets per stage and preventing prompt history context bloat during agent repairs are crucial for efficient and reliable workflow execution. By understanding the differences between shared global pools, isolated stage budgets, and stateful history append approaches, developers can design more robust state machines and avoid common architectural traps. Implementing these patterns ensures that your agent pipelines remain performant, cost-effective, and resilient to the inherent variability of large language models.</p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/llm-retry-budgets-per-stage-isolation-vs-pipeline-pools/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Introducing EgressVeil — Protect Your Secrets Before AI Coding Agents Send Them to the Cloud.</title>
		<link>https://codango.com/introducing-egressveil-protect-your-secrets-before-ai-coding-agents-send-them-to-the-cloud/</link>
					<comments>https://codango.com/introducing-egressveil-protect-your-secrets-before-ai-coding-agents-send-them-to-the-cloud/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Tue, 17 Nov 2026 22:27:47 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/introducing-egressveil-protect-your-secrets-before-ai-coding-agents-send-them-to-the-cloud/</guid>

					<description><![CDATA[Introducing EgressVeil — Protect Your Secrets Before AI Coding Agents Send Them to the Cloud. AI coding agents like Claude Code and Aider are transforming software development. But there&#8217;s a <a class="more-link" href="https://codango.com/introducing-egressveil-protect-your-secrets-before-ai-coding-agents-send-them-to-the-cloud/">Continue reading <span class="screen-reader-text">  Introducing EgressVeil — Protect Your Secrets Before AI Coding Agents Send Them to the Cloud.</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p><strong>Introducing EgressVeil — Protect Your Secrets Before AI Coding Agents Send Them to the Cloud.</strong></p>
<p>AI coding agents like Claude Code and Aider are transforming software development.</p>
<p>But there&#8217;s a security risk we don&#8217;t talk about enough.</p>
<p><strong>What happens when your AI agent accidentally sends API keys, credentials, customer information, or internal infrastructure details to an LLM provider?</strong></p>
<p>That&#8217;s the problem I built <strong>EgressVeil</strong> to help solve.</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f6e1.png" alt="🛡" class="wp-smiley" style="height: 1em; max-height: 1em;" /> <strong>EgressVeil is a free, open-source, local-first privacy gateway for AI coding agents.</strong></p>
<p>It sits between your AI coding agent and the LLM API, inspecting outgoing requests and applying security policies before sensitive information leaves your machine.</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f510.png" alt="🔐" class="wp-smiley" style="height: 1em; max-height: 1em;" /> <strong>Key Features:</strong></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2705.png" alt="✅" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Detects API keys, passwords, JWTs, tokens, and personal information</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2705.png" alt="✅" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Automatically redacts or blocks sensitive data</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2705.png" alt="✅" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Works with Claude Code and Aider</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2705.png" alt="✅" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Supports Anthropic and OpenAI-compatible APIs</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2705.png" alt="✅" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Configurable security policies: ALLOW, REDACT, BLOCK, and LOG_ONLY</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2705.png" alt="✅" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Local audit logging without exposing raw secrets</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2705.png" alt="✅" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Runs locally — no telemetry, no accounts, no subscriptions</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2705.png" alt="✅" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Cross-platform: Windows, Linux, and macOS</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2705.png" alt="✅" class="wp-smiley" style="height: 1em; max-height: 1em;" /> 100% free and open source (MIT License)</p>
<p><strong>Getting started is simple:</strong></p>
<p><code>pip install egressveil</code></p>
<p><code>egressveil run -- claude</code></p>
<p>EgressVeil is currently in <strong>beta</strong>, with live API validation completed for Claude Code and Aider.</p>
<p>It protects supported LLM API traffic routed through the gateway—not every network action an agent performs.</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4a1.png" alt="💡" class="wp-smiley" style="height: 1em; max-height: 1em;" /> <strong>My goal:</strong> Make privacy and security a default part of AI-assisted software development, not an afterthought.</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f517.png" alt="🔗" class="wp-smiley" style="height: 1em; max-height: 1em;" /> <strong>GitHub:</strong> <a href="https://github.com/qmmughal/egressveil" rel="noopener noreferrer">https://github.com/qmmughal/egressveil</a></p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2b50.png" alt="⭐" class="wp-smiley" style="height: 1em; max-height: 1em;" /> If you find it useful, consider starring the repository.</p>
<p><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f91d.png" alt="🤝" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Contributions, feedback, and security reviews are welcome!</p>
<p><strong>Question for developers:</strong> How are you preventing sensitive information from leaking through AI coding assistants today?</p>
<h1>
<p>  OpenSource #EgressVeil #AISecurity #ClaudeCode #AIAgents #CyberSecurity #Python #DevSecOps #DataPrivacy #AgenticAI<br />
</p></h1>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/introducing-egressveil-protect-your-secrets-before-ai-coding-agents-send-them-to-the-cloud/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>An emoji is a code point, not a picture: why the same &#x1f354; looks different on every device</title>
		<link>https://codango.com/an-emoji-is-a-code-point-not-a-picture-why-the-same-%f0%9f%8d%94-looks-different-on-every-device/</link>
					<comments>https://codango.com/an-emoji-is-a-code-point-not-a-picture-why-the-same-%f0%9f%8d%94-looks-different-on-every-device/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Tue, 17 Nov 2026 22:27:24 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/an-emoji-is-a-code-point-not-a-picture-why-the-same-%f0%9f%8d%94-looks-different-on-every-device/</guid>

					<description><![CDATA[If you have ever built a search box for a searchable list of food emoji, you have run into the same surprise: the thing you store is not an image. <a class="more-link" href="https://codango.com/an-emoji-is-a-code-point-not-a-picture-why-the-same-%f0%9f%8d%94-looks-different-on-every-device/">Continue reading <span class="screen-reader-text">  An emoji is a code point, not a picture: why the same &#x1f354; looks different on every device</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>If you have ever built a search box for a <a href="https://emojiwiz.com/food-emoji/" rel="noopener noreferrer">searchable list of food emoji</a>, you have run into the same surprise: the thing you store is not an image. It is a number, and every platform decides for itself what to draw for it.</p>
<h2>
<p>  What actually gets stored<br />
</p></h2>
<p>An emoji is a Unicode code point, for example <code>U+1F354</code> for &#8220;hamburger&#8221;. Unicode assigns that number an official name and a short description. It does not ship artwork. Apple, Google, Samsung and Microsoft each draw their own glyphs and bundle them into their own fonts.</p>
<p>So when a message goes from one phone to another, the code point arrives intact and the picture is replaced by the receiver&#8217;s version. Nothing is lost in transit. There is simply no single canonical burger.
</p>
<div class="highlight js-code-highlight">
<pre class="highlight javascript"><code><span class="s2">"&#x1f354;"</span><span class="p">.</span><span class="nf">codePointAt</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span><span class="p">.</span><span class="nf">toString</span><span class="p">(</span><span class="mi">16</span><span class="p">)</span><span class="p">;</span> <span class="c1">// "1f354"</span>
</code></pre>
</div>
<h2>
<p>  Why food emoji show the gap best<br />
</p></h2>
<p>Food emoji are tiny illustrations with plenty of detail: layers, garnish, colors. Vendor differences are easy to see there, and vendors have even redrawn some icons after public debates about the details. If a dish looks odd on your screen, check its name instead. The name is stable even when the picture is not.</p>
<h2>
<p>  Searching emoji properly<br />
</p></h2>
<p>A useful emoji search does not match only the name. Unicode CLDR provides a list of keywords for every emoji, and a decent implementation combines both:</p>
<ol>
<li>Lowercase the query and split it into words.</li>
<li>Match against the name and the CLDR keywords.</li>
<li>Rank exact whole-word matches above partial ones.</li>
</ol>
<p>Search for &#8220;cake&#8221; and you should get <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f382.png" alt="🎂" class="wp-smiley" style="height: 1em; max-height: 1em;" /> <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f370.png" alt="🍰" class="wp-smiley" style="height: 1em; max-height: 1em;" /> <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f9c1.png" alt="🧁" class="wp-smiley" style="height: 1em; max-height: 1em;" />. Search for &#8220;coffee&#8221; and you should get <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/2615.png" alt="☕" class="wp-smiley" style="height: 1em; max-height: 1em;" />.</p>
<p>Empty results are usually a data problem, not a bug: a dish with no emoji of its own cannot be found by its own name. A broader word such as &#8220;fruit&#8221; or &#8220;drink&#8221; works as a fallback.</p>
<h2>
<p>  Practical rules<br />
</p></h2>
<ul>
<li>Treat an emoji as a name plus a code point, and test how it renders on at least one device that is not yours.</li>
<li>Very new code points show up as an empty box on older systems, so keep a plain-text word next to anything important.</li>
<li>When copying emoji into a template, a menu or a shared list, check the result on a second platform before sending it to everyone.</li>
</ul>
<p>Emoji behave like a shared vocabulary, not a shared set of pictures. Each platform just draws the words in its own handwriting.</p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/an-emoji-is-a-code-point-not-a-picture-why-the-same-%f0%9f%8d%94-looks-different-on-every-device/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>An AI app for Android: ForgeMind, a Kotlin workstation for cloud and local models</title>
		<link>https://codango.com/an-ai-app-for-android-forgemind-a-kotlin-workstation-for-cloud-and-local-models/</link>
					<comments>https://codango.com/an-ai-app-for-android-forgemind-a-kotlin-workstation-for-cloud-and-local-models/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Tue, 17 Nov 2026 22:26:56 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/an-ai-app-for-android-forgemind-a-kotlin-workstation-for-cloud-and-local-models/</guid>

					<description><![CDATA[I work from a phone more often than I would like to admit. Most mobile AI apps I tried were front-ends: one provider, a prompt box, maybe a document picker. <a class="more-link" href="https://codango.com/an-ai-app-for-android-forgemind-a-kotlin-workstation-for-cloud-and-local-models/">Continue reading <span class="screen-reader-text">  An AI app for Android: ForgeMind, a Kotlin workstation for cloud and local models</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>I work from a phone more often than I would like to admit. Most mobile AI apps I tried were front-ends: one provider, a prompt box, maybe a document picker. As soon as I needed a shell on a VPS, a file on the phone, an MCP server at home, or the ability to tap something in another app, I was back at a computer.</p>
<p>So I built an AI app for Android. <strong><a href="https://github.com/DIIIUA/ForgeMind" rel="noopener noreferrer">ForgeMind</a></strong> is a native Kotlin + Jetpack Compose app. I wanted a workstation on the device, not another thin chat client: cloud and local models, SSH (including Cloudflare Access), MCP in both directions, files and a shell, and a way to read and operate the screen of other apps.</p>
<p>This article is about how it is put together, what I traded away, and how to try it. The repository is a new public release (mid-November 2026). ForgeMind is <strong>0.2.1-alpha</strong>.</p>
<h2>
<p>  A dual-contour hub on Android<br />
</p></h2>
<p>The short version of the architecture is in the README. The idea is a <strong>dual contour</strong> — external connections and on-device ones — without shipping a multi-gigabyte Linux container inside the APK.</p>
<p><strong>Outside the phone</strong>, the app speaks five native LLM wire protocols: OpenAI-compatible <code>/chat/completions</code> (SSE, with a non-SSE fallback), OpenAI <code>/responses</code>, Anthropic <code>/v1/messages</code>, Gemini <code>streamGenerateContent</code>, and Ollama&#8217;s native <code>/api/chat</code>. There are twelve cloud presets (OpenAI, Anthropic, Gemini, OpenRouter, DeepSeek, xAI Grok, Groq, Mistral, Venice AI, NVIDIA NIM, Cloudflare Workers AI, Hugging Face), plus arbitrary custom HTTP gateways (six auth modes, custom headers and body, optional insecure TLS for LAN, DNS-over-HTTPS fallback), plus a LAN scanner. You can probe a single <code>IP:port</code> in about a second, or scan the <code>/24</code> for servers such as Ollama, LM Studio, llama.cpp, KoboldCpp, vLLM, SGLang, LocalAI, Jan, GPT4All, OpenWebUI, and LiteLLM.</p>
<p>SSH and SFTP use JSch, with password or key auth, over a public IP, a VPN, or Tailscale. For Zero Trust I implemented Cloudflare Access SSH over <code>wss://</code>: the app sends <code>CF-Access-Client-Id</code> and <code>CF-Access-Client-Secret</code> and does not need a <code>cloudflared</code> binary on Android, and the server does not need an open SSH port.</p>
<p>MCP is bidirectional. As a client, ForgeMind supports Streamable HTTP (<code>POST /mcp</code>), HTTP+SSE, and <code>SSH_STDIO</code> (it can spawn <code>npx</code>, <code>uvx</code>, or <code>python3</code> MCP servers on a remote host or in Termux). As a host, a built-in Streamable HTTP server listens on <code>127.0.0.1:8765</code> (<code>/mcp</code> and <code>/health</code>, Bearer token, toggles for write/shell) so a local agent, Termux, <code>adb forward</code>, or a tunnel can call the phone&#8217;s tools.</p>
<p><strong>On the device</strong>, four file environments share a dual-pane manager: the app sandbox, shared phone storage, Storage Access Framework folders, and SFTP. The Sora editor shows unified diffs and takes a rollback snapshot before an edit. A persistent <code>/system/bin/sh</code> keeps its working directory if SSH drops. Termux is a first-class contour (<code>127.0.0.1:2222</code> and <code>RUN_COMMAND</code>). There is an 8-window &#8220;Turbo&#8221; agent browser, separate from the ordinary in-app browser, and a floating chat overlay.</p>
<p>The part I get asked about most is screen control. After you opt in to the Accessibility service, ForgeMind can read the visible text and controls of other apps as a tagged tree (<code>[#1]…</code>, windows <code>[W1]…</code>, including split screen, floating windows, and the IME), then tap, type, or scroll by tag, including a batch of actions in one call. Screenshots are on demand (Android 11+), not a background recording. Android still hides password fields, and <code>FLAG_SECURE</code> still blocks screenshots. I call this out because &#8220;the agent can use your phone&#8221; should not sound magical.</p>
<p>Under the chat loop there are <strong>56 built-in tools</strong> (29 core + 27 in-app levers), plus whatever an attached MCP server adds. For small local GGUF models the schema is compacted automatically, and the parser understands seven inline tool-call syntaxes. The model picker can auto-detect a loaded context window (LM Studio, llama.cpp, Ollama, <code>/v1/models</code>) and override it with one tap.</p>
<p><strong>Tradeoffs I accepted.</strong> This is an alpha. The first public tag was <code>v0.1.0-alpha</code> on 13 November 2026; <code>v0.2.1-alpha</code> followed a day later, mainly to stop the model picker crashing on aggregator catalogs with more than a thousand models. Accessibility is powerful and easy to get wrong on OEM skins (the README already mentions HyperOS / MIUI overlays). I encrypt secrets on the device with AES-256-GCM and do not ship API keys in the repo, but you are still putting a tool-using agent on a phone — the approval toggles and destructive-shell intercepts are there for a reason. The project is <strong>GPL-3.0</strong>; I retain the right to ship official builds under a separate commercial license.</p>
<p><strong>Requirements:</strong> Android 10+ (API 29, compile SDK 36), Kotlin 2.2.21. I currently ship a prerelease APK from <a href="https://github.com/DIIIUA/ForgeMind/releases/latest" rel="noopener noreferrer">GitHub Releases</a> (<code>ForgeMind-v0.2.1-alpha.apk</code>). You can also add <code>https://github.com/DIIIUA/ForgeMind</code> in <a href="https://github.com/ImranR98/Obtainium" rel="noopener noreferrer">Obtainium</a> with <em>Include prereleases</em> enabled, or build from source:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight shell"><code>git clone https://github.com/DIIIUA/ForgeMind.git
<span class="nb">cd</span> ForgeMind
./gradlew testDebugUnitTest assembleDebug
</code></pre>
</div>
<p>That Gradle invocation is also how I run the 96 unit tests. After install: <strong>Settings → AI Providers</strong> for a cloud key or a custom endpoint; <strong>Find Local AIs in Network</strong> for LAN servers; <strong>Environments</strong> for Termux or Cloudflare SSH; <strong>MCP Servers</strong> for client transports or the on-device host.</p>
<p>A live portal and the screenshots used in the README are at <a href="https://diiiua.github.io/ForgeMind/" rel="noopener noreferrer">diiiua.github.io/ForgeMind</a>.</p>
<h2>
<p>  What is still rough<br />
</p></h2>
<p>ForgeMind is alpha software. I would not treat it as a daily driver without watching the first tool calls yourself, especially anything that writes files, runs a shell, or drives the Accessibility service. The APK is a GitHub prerelease, not a store build.</p>
<h2>
<p>  What I would like to hear back<br />
</p></h2>
<p>How reliable tool calling is on the local models you actually run; whether LAN discovery finds your stack; how the Window-Tag actions behave on your OEM skin; and which parts feel unfinished for a post-alpha release.</p>
<p>Issues and pull requests are welcome. Please do not open a PR that includes API keys, hostnames, or device identifiers.</p>
<h2>
<p>  Links<br />
</p></h2>
<ul>
<li>ForgeMind (Kotlin, Android, GPL-3.0, v0.2.1-alpha): <a href="https://github.com/DIIIUA/ForgeMind" rel="noopener noreferrer">github.com/DIIIUA/ForgeMind</a> · <a href="https://github.com/DIIIUA/ForgeMind/releases/latest" rel="noopener noreferrer">Releases</a> · <a href="https://diiiua.github.io/ForgeMind/" rel="noopener noreferrer">Website</a>
</li>
</ul>
<p>I am Anton (<a href="https://github.com/DIIIUA" rel="noopener noreferrer">DIIIUA</a>). If you try the app, I am more interested in a failed setup or a wrong tool call than in a compliment.</p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/an-ai-app-for-android-forgemind-a-kotlin-workstation-for-cloud-and-local-models/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>AI Breakthrough Personalizes Prostate Cancer Treatment</title>
		<link>https://codango.com/ai-breakthrough-personalizes-prostate-cancer-treatment/</link>
					<comments>https://codango.com/ai-breakthrough-personalizes-prostate-cancer-treatment/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Tue, 17 Nov 2026 18:53:01 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/ai-breakthrough-personalizes-prostate-cancer-treatment/</guid>

					<description><![CDATA[In a significant advancement for prostate cancer care, researchers from the US, UK, and Switzerland have developed an artificial intelligence (AI) tool capable of predicting which men with high-risk, non-metastatic <a class="more-link" href="https://codango.com/ai-breakthrough-personalizes-prostate-cancer-treatment/">Continue reading <span class="screen-reader-text">  AI Breakthrough Personalizes Prostate Cancer Treatment</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>In a significant advancement for prostate cancer care, researchers from the US, UK, and Switzerland have developed an artificial intelligence (AI) tool capable of predicting which men with high-risk, non-metastatic prostate cancer will benefit from the drug abiraterone. This development, unveiled at the American Society of Clinical Oncology’s annual meeting, promises to tailor treatment plans more effectively, potentially improving outcomes and reducing unnecessary side effects. </p>
<p>Abiraterone, often described as a “gamechanger” for advanced prostate cancer, has been shown to significantly reduce the risk of death. However, its use in earlier stages of the disease has been limited due to potential side effects, including increased risks of heart issues and diabetes. The new AI tool analyzes biopsy images to identify a biomarker indicating likely benefit from abiraterone. In a study involving over 1,000 men, the AI identified that approximately 25% had biomarker-positive tumors. For these individuals, abiraterone halved the five-year mortality rate from 17% to 9%. Conversely, for those without the biomarker, the benefit was negligible. </p>
<p>This breakthrough could lead to more personalized treatment strategies, ensuring that patients receive therapies most likely to benefit them while avoiding unnecessary exposure to potential side effects. It also has implications for healthcare systems, potentially prompting revisions in treatment guidelines and drug approval policies.  </p>
<p>Experts have lauded the development, emphasizing its potential to optimize personalized cancer care and improve patient outcomes. </p>
<p>For more details, read the full article here:<br />
<a href="https://www.theguardian.com/society/2025/may/30/new-ai-test-can-predict-which-men-will-benefit-from-prostate-cancer-drug" rel="noopener noreferrer">https://www.theguardian.com/society/2025/may/30/new-ai-test-can-predict-which-men-will-benefit-from-prostate-cancer-drug</a></p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/ai-breakthrough-personalizes-prostate-cancer-treatment/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Why Google Maps Search Caps at ~120 Results (and How a Quadtree Scan Gets the Rest)</title>
		<link>https://codango.com/why-google-maps-search-caps-at-120-results-and-how-a-quadtree-scan-gets-the-rest/</link>
					<comments>https://codango.com/why-google-maps-search-caps-at-120-results-and-how-a-quadtree-scan-gets-the-rest/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Tue, 17 Nov 2026 02:00:03 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/why-google-maps-search-caps-at-120-results-and-how-a-quadtree-scan-gets-the-rest/</guid>

					<description><![CDATA[Why Google Maps Search Caps at ~120 Results (and How a Quadtree Scan Gets the Rest) Search for &#8220;dentist&#8221; in a big city on Google Maps and scroll the results: <a class="more-link" href="https://codango.com/why-google-maps-search-caps-at-120-results-and-how-a-quadtree-scan-gets-the-rest/">Continue reading <span class="screen-reader-text">  Why Google Maps Search Caps at ~120 Results (and How a Quadtree Scan Gets the Rest)</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<h1>
<p>  Why Google Maps Search Caps at ~120 Results (and How a Quadtree Scan Gets the Rest)<br />
</p></h1>
<p>Search for &#8220;dentist&#8221; in a big city on Google Maps and scroll the results: the list stops long before the businesses actually run out. Tools that scrape or query Maps data commonly report a ceiling of roughly 120 results per search — and what you see can vary by place, by query, and over time.</p>
<p>This isn&#8217;t a bug. It&#8217;s worth understanding why it happens before you write code to work around it.</p>
<blockquote>
<p><strong>Disclosure:</strong> I work on <a href="https://leads.axioapi.com/" rel="noopener noreferrer">Axio Leads</a>, a Google Maps data-extraction tool. This post explains the underlying mechanism, not just our product.</p>
</blockquote>
<h2>
<p>  Maps is a search engine, not a directory<br />
</p></h2>
<p>Google Maps ranks businesses for a query around a place — it&#8217;s built to show you the best matches near you, not to enumerate every business in a category. That&#8217;s a fundamentally different job than a database dump.</p>
<p>That&#8217;s also why exporting &#8220;all dentists in a city&#8221; from a single search can never be complete: the search was never designed to return all of them. Even the official <a href="https://developers.google.com/maps/documentation/places/web-service/overview" rel="noopener noreferrer">Places API</a> returns results in small, paginated batches rather than a full category listing — the limitation is structural, not an artifact of any particular scraping method.</p>
<h2>
<p>  Workarounds that actually help<br />
</p></h2>
<p>You get more of the real list by changing what you ask for, not by asking harder:</p>
<ul>
<li>
<strong>Search smaller areas</strong> — one district or neighborhood at a time, instead of a whole city in one query.</li>
<li>
<strong>Vary the keyword/category</strong> — &#8220;dentist&#8221;, &#8220;dental clinic&#8221;, &#8220;orthodontist&#8221; can each surface a slightly different slice of the same underlying businesses.</li>
<li>
<strong>De-duplicate by place ID</strong> — combining results from overlapping searches will return the same business more than once.</li>
</ul>
<p>Manually, this works but doesn&#8217;t scale. For one city, that&#8217;s a lot of searches to run and dedupe by hand.</p>
<h2>
<p>  Doing it systematically: a quadtree-style scan<br />
</p></h2>
<p>The programmatic version of &#8220;search smaller areas&#8221; is to split your target area into a grid of cells, search each cell independently, and recursively subdivide any cell that comes back &#8220;full&#8221; (i.e., hit the page cap) into four smaller cells — stopping once a cell returns fewer than a full page.</p>
<p>That&#8217;s the idea behind a <a href="https://en.wikipedia.org/wiki/Quadtree" rel="noopener noreferrer">quadtree</a>: a structure that recursively subdivides space only where there&#8217;s more to describe. It keeps your request count roughly proportional to business density, not to the raw size of the area — a quiet suburb costs one request, a dense downtown core gets split repeatedly.</p>
<p>A minimal version of the recursion looks like this:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight python"><code><span class="k">def</span> <span class="nf">scan_cell</span><span class="p">(</span><span class="n">bbox</span><span class="p">,</span> <span class="n">keyword</span><span class="p">,</span> <span class="n">depth</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">max_depth</span><span class="o">=</span><span class="mi">6</span><span class="p">)</span><span class="p">:</span>
    <span class="s2">"""bbox = (south, west, north, east). Returns a list of place results."""</span>
    <span class="n">results</span> <span class="o">=</span> <span class="nf">search_places</span><span class="p">(</span><span class="n">bbox</span><span class="p">,</span> <span class="n">keyword</span><span class="p">)</span>  <span class="c1"># however you call Maps/Places for this area</span>

    <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">results</span><span class="p">)</span> <span class="o">&lt;</span> <span class="no">PAGE_SIZE</span> <span class="ow">or</span> <span class="n">depth</span> <span class="o">&gt;=</span> <span class="n">max_depth</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">results</span>

    <span class="c1"># Cell came back "full" — split into four quadrants and recurse.</span>
    <span class="n">south</span><span class="p">,</span> <span class="n">west</span><span class="p">,</span> <span class="n">north</span><span class="p">,</span> <span class="n">east</span> <span class="o">=</span> <span class="n">bbox</span>
    <span class="n">mid_lat</span> <span class="o">=</span> <span class="p">(</span><span class="n">south</span> <span class="o">+</span> <span class="n">north</span><span class="p">)</span> <span class="o">/</span> <span class="mi">2</span>
    <span class="n">mid_lng</span> <span class="o">=</span> <span class="p">(</span><span class="n">west</span> <span class="o">+</span> <span class="n">east</span><span class="p">)</span> <span class="o">/</span> <span class="mi">2</span>
    <span class="n">quadrants</span> <span class="o">=</span> <span class="p">[</span>
        <span class="p">(</span><span class="n">south</span><span class="p">,</span> <span class="n">west</span><span class="p">,</span> <span class="n">mid_lat</span><span class="p">,</span> <span class="n">mid_lng</span><span class="p">)</span><span class="p">,</span>
        <span class="p">(</span><span class="n">south</span><span class="p">,</span> <span class="n">mid_lng</span><span class="p">,</span> <span class="n">mid_lat</span><span class="p">,</span> <span class="n">east</span><span class="p">)</span><span class="p">,</span>
        <span class="p">(</span><span class="n">mid_lat</span><span class="p">,</span> <span class="n">west</span><span class="p">,</span> <span class="n">north</span><span class="p">,</span> <span class="n">mid_lng</span><span class="p">)</span><span class="p">,</span>
        <span class="p">(</span><span class="n">mid_lat</span><span class="p">,</span> <span class="n">mid_lng</span><span class="p">,</span> <span class="n">north</span><span class="p">,</span> <span class="n">east</span><span class="p">)</span><span class="p">,</span>
    <span class="p">]</span>

    <span class="n">merged</span> <span class="o">=</span> <span class="p">[</span><span class="p">]</span>
    <span class="k">for</span> <span class="n">quad</span> <span class="k">in</span> <span class="n">quadrants</span><span class="p">:</span>
        <span class="n">merged</span><span class="p">.</span><span class="nf">extend</span><span class="p">(</span><span class="nf">scan_cell</span><span class="p">(</span><span class="n">quad</span><span class="p">,</span> <span class="n">keyword</span><span class="p">,</span> <span class="n">depth</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="n">max_depth</span><span class="p">)</span><span class="p">)</span>

    <span class="k">return</span> <span class="n">merged</span>


<span class="k">def</span> <span class="nf">dedupe_by_place_id</span><span class="p">(</span><span class="n">results</span><span class="p">)</span><span class="p">:</span>
    <span class="n">seen</span> <span class="o">=</span> <span class="p">{</span><span class="p">}</span>
    <span class="k">for</span> <span class="n">r</span> <span class="k">in</span> <span class="n">results</span><span class="p">:</span>
        <span class="n">seen</span><span class="p">[</span><span class="n">r</span><span class="p">[</span><span class="s2">"place_id"</span><span class="p">]</span><span class="p">]</span> <span class="o">=</span> <span class="n">r</span>  <span class="c1"># last write wins; place_id is stable across overlapping cells</span>
    <span class="k">return</span> <span class="kt">list</span><span class="p">(</span><span class="n">seen</span><span class="p">.</span><span class="nf">values</span><span class="p">(</span><span class="p">)</span><span class="p">)</span>
</code></pre>
</div>
<p>A few things worth calling out about this shape of solution:</p>
<ul>
<li>
<strong>Neighboring cells overlap at their boundaries</strong>, so the same business can legitimately appear in more than one cell&#8217;s results — dedupe by a stable identifier (place ID), not by name/address matching.</li>
<li>
<strong><code>max_depth</code> is a cost control, not a correctness guarantee.</strong> Without it, a sufficiently dense area (or a bug in your &#8220;is this cell full&#8221; check) can recurse a very long time. Cap it, and log when you hit the cap so you know your coverage might be incomplete there.</li>
<li>
<strong>This will not return literally every business.</strong> A listing can be missing, closed, or filed under a category you didn&#8217;t search. Treat the output as a very large sample of the area, not a census — and preview a small area before running (and paying for, if you&#8217;re using a paid API/tool) a large one.</li>
</ul>
<h2>
<p>  Why not just use a tiny bounding box everywhere?<br />
</p></h2>
<p>You could skip the recursion and just search with a very small, fixed-size box across the whole target area. It finds almost everything in each box, but covering a city that way means issuing thousands of searches — the overwhelming majority of them in areas with little or nothing in them.</p>
<p>Starting large and only splitting where a cell actually comes back full gets you the same coverage with far fewer requests. The recursion is doing the work of figuring out where detail is actually needed.</p>
<h2>
<p>  FAQ<br />
</p></h2>
<p><strong>Is the limit exactly 120?</strong><br />
Not necessarily. Different tools and docs cite &#8220;about 120&#8221; as the practical ceiling, but what you observe depends on the query, the place, and Google&#8217;s own ranking — and it can change over time. Don&#8217;t hardcode assumptions about the exact number into your stopping condition; use &#8220;did this page come back full&#8221; instead.</p>
<p><strong>Why do I see duplicates when I combine searches?</strong><br />
Overlapping cells return the same business more than once. Dedupe by place ID (or whatever stable identifier your data source gives you) so each business appears once in your final output.</p>
<p><strong>Does a bigger area always return more results?</strong><br />
Only if the area actually contains more matching businesses. A large rural bounding box can return fewer results than one dense urban district.</p>
<p><strong>Can I get literally every business in a category this way?</strong><br />
No. No scanning method — ours included — guarantees a complete census. Some listings are missing, some are miscategorized, some are closed-but-not-marked-closed. A systematic scan gets you very close to the <em>visible</em> set, which is usually what you actually need for prospecting, research, or market analysis.</p>
<p>If you&#8217;ve built something similar — tiling an API with a hard per-request result cap — I&#8217;d be curious what <code>max_depth</code> and cell-size defaults you landed on, and how you detected &#8220;this cell needs splitting&#8221; for your particular API.</p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/why-google-maps-search-caps-at-120-results-and-how-a-quadtree-scan-gets-the-rest/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>UPC Check Digits: The One-Digit Lie That Still Scans Perfectly</title>
		<link>https://codango.com/upc-check-digits-the-one-digit-lie-that-still-scans-perfectly/</link>
					<comments>https://codango.com/upc-check-digits-the-one-digit-lie-that-still-scans-perfectly/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Tue, 17 Nov 2026 02:00:00 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/upc-check-digits-the-one-digit-lie-that-still-scans-perfectly/</guid>

					<description><![CDATA[A UPC-A barcode can be perfectly valid and completely wrong for your product. Those are not opposites. They are the same bug wearing a very convincing disguise. The last digit <a class="more-link" href="https://codango.com/upc-check-digits-the-one-digit-lie-that-still-scans-perfectly/">Continue reading <span class="screen-reader-text">  UPC Check Digits: The One-Digit Lie That Still Scans Perfectly</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<p>A UPC-A barcode can be perfectly valid and completely wrong for your product. Those are not opposites. They are the same bug wearing a very convincing disguise.</p>
<p>The last digit of a 12-digit UPC-A is not a serial number and it is not a sanity check against GS1&#8217;s database. It is just arithmetic. If you change one digit in the payload and recompute the check digit, the new barcode is mathematically valid. A scanner will happily read it. Your inventory system will happily file it under the wrong coffee mug.</p>
<h2>
<p>  The math is only five lines long<br />
</p></h2>
<p>Take the first 11 digits. Multiply digits in positions 1, 3, 5, 7, 9 and 11 by 3. Add the even-position digits. Find the number that brings the total to the next multiple of 10.
</p>
<div class="highlight js-code-highlight">
<pre class="highlight javascript"><code><span class="kd">function</span> <span class="nf">upcCheckDigit</span><span class="p">(</span><span class="n">eleven</span><span class="p">)</span> <span class="p">{</span>
  <span class="kd">let</span> <span class="n">sum</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
  <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="mi">11</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
    <span class="n">sum</span> <span class="o">+=</span> <span class="nb">Number</span><span class="p">(</span><span class="n">eleven</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">i</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">===</span> <span class="mi">0</span> <span class="o">?</span> <span class="mi">3</span> <span class="p">:</span> <span class="mi">1</span><span class="p">)</span><span class="p">;</span>
  <span class="p">}</span>
  <span class="k">return</span> <span class="nb">String</span><span class="p">(</span><span class="p">(</span><span class="mi">10</span> <span class="o">-</span> <span class="p">(</span><span class="n">sum</span> <span class="o">%</span> <span class="mi">10</span><span class="p">)</span><span class="p">)</span> <span class="o">%</span> <span class="mi">10</span><span class="p">)</span><span class="p">;</span>
<span class="p">}</span>
</code></pre>
</div>
<p>For <code>03600029145</code>, that produces <code>2</code>, so the complete code is <code>036000291452</code>.</p>
<p>EAN-13 flips the weights: odd positions ×1, even positions ×3. This is why copying a UPC routine into an EAN form and changing only the expected length is such an effective way to manufacture bad labels at scale.</p>
<h2>
<p>  What the check digit actually proves<br />
</p></h2>
<p>It proves only this: the digits did not get mangled in the way Modulo-10 is designed to catch. It does not prove:</p>
<ul>
<li>that GS1 issued the prefix to your company;</li>
<li>that the code belongs to this product;</li>
<li>that the seller who exported the CSV put the right code on the right row;</li>
<li>that a 14-digit shipping-carton code was supposed to be here at all.</li>
</ul>
<p>The dangerous version of this bug is not a rejected barcode. It is a barcode that passes every technical check and still points to another SKU.</p>
<h2>
<p>  The worst helper: silent truncation<br />
</p></h2>
<p>A seller pastes a 14-digit GTIN-14 case code into a UPC-A field. Many forms &#8216;help&#8217; by cutting it down to 11 digits and recomputing the last digit. The result is valid UPC-A art. It is also a different trade item.</p>
<p>In the <a href="https://upclabelmaker.com/upc-label-generator" rel="noopener noreferrer">UPC Label Maker generator</a>, a 14-digit input is refused instead of trimmed. The useful answer is not a prettier error message; it is a route to the <a href="https://upclabelmaker.com/gs1-datamatrix-generator" rel="noopener noreferrer">GS1 DataMatrix generator</a>, where a GTIN-14 belongs. EAN-13 gets the same guard in the <a href="https://upclabelmaker.com/ean-13-label-generator" rel="noopener noreferrer">EAN-13 label generator</a>.</p>
<p>If you need the arithmetic without the layout machinery, the <a href="https://upclabelmaker.com/check-digit-calculator" rel="noopener noreferrer">UPC and EAN check digit calculator</a> shows whether an existing final digit matches. In the <a href="https://upclabelmaker.com/bulk-barcode-generator" rel="noopener noreferrer">bulk barcode generator</a>, bad rows are listed and skipped. They are not silently repaired into plausible-looking inventory IDs.</p>
<h2>
<p>  A check worth stealing<br />
</p></h2>
<p>Before trusting a barcode form, give it these four inputs:</p>
<ol>
<li>Eleven valid digits: it should append the check digit.</li>
<li>Twelve digits with a wrong final digit: it should flag the mismatch, explicitly.</li>
<li>Fourteen digits: it should refuse to turn them into a UPC.</li>
<li>A repeated code in a CSV: it should point at both source lines.</li>
</ol>
<p>The whole point of a check digit is to catch mistakes. Using it to bless a different product is the barcode equivalent of a smoke detector that plays music during a fire.</p>
<p>If you want the longer comparison of UPC-A, EAN-13 and GTIN-14—including when leading zeros change nothing—the project’s <a href="https://upclabelmaker.com/guides/upc-a-vs-ean-13-vs-gtin-14" rel="noopener noreferrer">UPC vs EAN vs GTIN guide</a> has the examples laid out.</p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/upc-check-digits-the-one-digit-lie-that-still-scans-perfectly/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>pull_request_target gets blocked on Dec 2. Here&#8217;s a 10-minute check</title>
		<link>https://codango.com/pull_request_target-gets-blocked-on-dec-2-heres-a-10-minute-check/</link>
					<comments>https://codango.com/pull_request_target-gets-blocked-on-dec-2-heres-a-10-minute-check/#respond</comments>
		
		<dc:creator><![CDATA[]]></dc:creator>
		<pubDate>Tue, 17 Nov 2026 02:00:00 +0000</pubDate>
				<category><![CDATA[Codango® Blog]]></category>
		<guid isPermaLink="false">https://codango.com/pull_request_target-gets-blocked-on-dec-2-heres-a-10-minute-check/</guid>

					<description><![CDATA[<img width="150" height="150" src="https://codango.com/wp-content/uploads/https3A2F2Fdev-to-uploads.s3.us-east-2.amazonaws.com2Fuploads2Farticles2Fl3r4f0vwoyw9j3logwkq-S5BhYB-150x150.webp" class="attachment-thumbnail size-thumbnail wp-post-image" alt="" decoding="async" />Did a workflow on your public repo fail on November 16 between 16:00 and 18:00 UTC, and then quietly start working again? That wasn&#8217;t a flaky runner. It was GitHub <a class="more-link" href="https://codango.com/pull_request_target-gets-blocked-on-dec-2-heres-a-10-minute-check/">Continue reading <span class="screen-reader-text">  pull_request_target gets blocked on Dec 2. Here&#8217;s a 10-minute check</span><span class="meta-nav">&#8594;</span></a>]]></description>
										<content:encoded><![CDATA[<img width="150" height="150" src="https://codango.com/wp-content/uploads/https3A2F2Fdev-to-uploads.s3.us-east-2.amazonaws.com2Fuploads2Farticles2Fl3r4f0vwoyw9j3logwkq-S5BhYB-150x150.webp" class="attachment-thumbnail size-thumbnail wp-post-image" alt="" decoding="async" /><p>Did a workflow on your public repo fail on November 16 between 16:00 and 18:00 UTC, and then quietly start working again? That wasn&#8217;t a flaky runner. It was GitHub rehearsing a change.</p>
<p>From <strong>December 2, 2026</strong>, GitHub Actions blocks <code>pull_request_target</code> by default in public repositories, unless an Actions event policy explicitly allows it. If your auto-labeler, first-time-contributor greeter or preview deploy runs on that trigger, it stops on that day.</p>
<p>This post is for anyone who maintains a public repo on GitHub Free, Team or Enterprise Cloud. In about ten minutes you&#8217;ll know which of your workflows use the trigger, and for each one, whether to switch it, split it or allow it.</p>
<h2>
<p>  What exactly changes<br />
</p></h2>
<p>The short version from <a href="https://github.blog/changelog/2026-11-02-pull_request_target-blocked-by-default-december-2" rel="noopener noreferrer">GitHub&#8217;s changelog</a>:</p>
<ul>
<li>
<strong>Who:</strong> public repositories on GitHub Free, GitHub Team and GitHub Enterprise Cloud. Private and internal repos aren&#8217;t affected, and neither is GitHub Enterprise Server.</li>
<li>
<strong>When:</strong> permanently from December 2, 2026. It was first planned for November 2 and got pushed back a month.</li>
<li>
<strong>Rehearsals:</strong> two brownouts, on November 9 and November 16, 16:00 to 18:00 UTC. During those windows, blocked runs failed with an error annotation. Outside them, the rule sits in evaluate mode, so runs still go through with a warning.</li>
<li>
<strong>Escape hatch:</strong> an Actions event policy that explicitly allows <code>pull_request_target</code>, ideally scoped to specific workflow files.</li>
</ul>
<p>Both brownouts are done. The next time it blocks, it stays blocked.</p>
<h2>
<p>  Why GitHub is doing this<br />
</p></h2>
<p>The two triggers look almost identical, and that&#8217;s the problem.</p>
<p><a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fl3r4f0vwoyw9j3logwkq.png" class="article-body-image-wrapper"><img fetchpriority="high" decoding="async" src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fl3r4f0vwoyw9j3logwkq.png" alt="inline" width="800" height="742" /></a></p>
<p><code>pull_request</code> runs the workflow file from the PR&#8217;s merge commit. For a fork PR, that code belongs to someone with no write access to your repo, so GitHub gives the job a read-only <code>GITHUB_TOKEN</code> and no secrets.</p>
<p><code>pull_request_target</code> runs the workflow from your default branch instead, with the base repo&#8217;s <code>GITHUB_TOKEN</code> and access to repository and organization secrets. That&#8217;s useful for jobs like labelling or commenting on fork PRs. On its own it&#8217;s safe, because nothing from the fork runs by default.</p>
<p>It turns dangerous the moment the workflow checks out the fork&#8217;s code and executes it. Here&#8217;s the shape GitHub&#8217;s own docs use as the bad example:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight yaml"><code><span class="c1"># INSECURE. Example only.
</span><span class="na">on</span><span class="p">:</span>
  <span class="na">pull_request_target</span><span class="p">:</span>

<span class="na">jobs</span><span class="p">:</span>
  <span class="na">build</span><span class="p">:</span>
    <span class="na">runs-on</span><span class="p">:</span> <span class="s">ubuntu-latest</span>
    <span class="na">steps</span><span class="p">:</span>
      <span class="p">-</span> <span class="na">uses</span><span class="p">:</span> <span class="s">actions/checkout@v6</span>
        <span class="na">with</span><span class="p">:</span>
          <span class="na">ref</span><span class="p">:</span> <span class="s">${{ github.event.pull_request.head.sha }}</span>
      <span class="p">-</span> <span class="na">name</span><span class="p">:</span> <span class="s">Test</span>
        <span class="na">run</span><span class="p">:</span> <span class="s">make test</span>
</code></pre>
</div>
<p>The checkout isn&#8217;t the bug. The <code>make test</code> line is. It runs a Makefile the PR author wrote, with your secrets in reach. GitHub&#8217;s docs call this pattern a &#8220;pwn request&#8221;, and it has caused multiple supply-chain compromises.</p>
<p>&#8220;Running&#8221; is broader than it sounds, too. Build scripts, test configs, <code>npm install</code> lifecycle hooks: any of them can execute code from the PR. You don&#8217;t need an obvious <code>run: ./evil.sh</code> step to get owned.</p>
<h2>
<p>  Step 1: find every workflow that uses it<br />
</p></h2>
<p>Start local. From the repo root:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight shell"><code>grep -rln <span class="s2">"pull_request_target"</span> .github/workflows
</code></pre>
</div>
<p>If you look after a whole org, GitHub code search does the same job across every repo:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight plaintext"><code>org:YOUR_ORG path:.github/workflows "pull_request_target"
</code></pre>
</div>
<p>A list of files is a start, but you also want to know which ones actually touch PR code. This small Node script (no dependencies, Node 18+) lists every workflow that uses the trigger and flags the lines that check out or fetch code from the PR:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight javascript"><code><span class="c1">// find-prt.mjs: list workflows that use pull_request_target and flag risky lines</span>
<span class="k">import</span> <span class="p">{</span> <span class="n">readdirSync</span><span class="p">,</span> <span class="n">readFileSync</span> <span class="p">}</span> <span class="k">from</span> <span class="s2">"node:fs"</span><span class="p">;</span>
<span class="k">import</span> <span class="p">{</span> <span class="n">join</span> <span class="p">}</span> <span class="k">from</span> <span class="s2">"node:path"</span><span class="p">;</span>

<span class="kd">const</span> <span class="n">dir</span> <span class="o">=</span> <span class="nb">process</span><span class="p">.</span><span class="n">argv</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">??</span> <span class="s2">".github/workflows"</span><span class="p">;</span>

<span class="kd">const</span> <span class="n">risky</span> <span class="o">=</span> <span class="p">[</span>
  <span class="p">[</span><span class="o">/</span><span class="n">ref</span><span class="p">:</span><span class="n">s</span><span class="o">*</span>$<span class="p">{</span><span class="p">{</span><span class="n">s</span><span class="o">*</span><span class="n">github</span><span class="p">.</span><span class="n">event</span><span class="p">.</span><span class="n">pull_request</span><span class="p">.</span><span class="n">head</span><span class="o">/</span><span class="p">,</span> <span class="s2">"checks out the PR head"</span><span class="p">]</span><span class="p">,</span>
  <span class="p">[</span><span class="o">/</span><span class="n">refs</span><span class="o">/</span><span class="n">pull</span><span class="c1">//, "checks out a PR ref"],</span>
  <span class="p">[</span><span class="o">/</span><span class="n">repository</span><span class="p">:</span><span class="n">s</span><span class="o">*</span>$<span class="p">{</span><span class="p">{</span><span class="n">s</span><span class="o">*</span><span class="n">github</span><span class="p">.</span><span class="n">event</span><span class="p">.</span><span class="n">pull_request</span><span class="p">.</span><span class="n">head</span><span class="p">.</span><span class="n">repo</span><span class="o">/</span><span class="p">,</span> <span class="s2">"checks out the fork repo"</span><span class="p">]</span><span class="p">,</span>
  <span class="p">[</span><span class="o">/</span><span class="n">gh</span> <span class="n">pr</span> <span class="n">checkout</span><span class="o">|</span><span class="n">git</span> <span class="nb">fetch</span><span class="o">/</span><span class="p">,</span> <span class="s2">"fetches PR code outside actions/checkout"</span><span class="p">]</span><span class="p">,</span>
  <span class="p">[</span><span class="o">/</span><span class="n">allow</span><span class="o">-</span><span class="n">unsafe</span><span class="o">-</span><span class="n">pr</span><span class="o">-</span><span class="n">checkout</span><span class="o">/</span><span class="p">,</span> <span class="s2">"opts out of checkout's fork protection"</span><span class="p">]</span><span class="p">,</span>
<span class="p">]</span><span class="p">;</span>

<span class="kd">const</span> <span class="n">files</span> <span class="o">=</span> <span class="nf">readdirSync</span><span class="p">(</span><span class="n">dir</span><span class="p">)</span><span class="p">.</span><span class="nf">filter</span><span class="p">(</span><span class="p">(</span><span class="n">f</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="o">/</span><span class="p">.</span><span class="n">ya</span><span class="o">?</span><span class="n">ml</span>$<span class="o">/</span><span class="p">.</span><span class="nf">test</span><span class="p">(</span><span class="n">f</span><span class="p">)</span><span class="p">)</span><span class="p">;</span>

<span class="k">for</span> <span class="p">(</span><span class="kd">const</span> <span class="n">file</span> <span class="k">of</span> <span class="n">files</span><span class="p">)</span> <span class="p">{</span>
  <span class="kd">const</span> <span class="n">lines</span> <span class="o">=</span> <span class="nf">readFileSync</span><span class="p">(</span><span class="nf">join</span><span class="p">(</span><span class="n">dir</span><span class="p">,</span> <span class="n">file</span><span class="p">)</span><span class="p">,</span> <span class="s2">"utf8"</span><span class="p">)</span><span class="p">.</span><span class="nf">split</span><span class="p">(</span><span class="s2">"n"</span><span class="p">)</span><span class="p">;</span>
  <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">lines</span><span class="p">.</span><span class="nf">some</span><span class="p">(</span><span class="p">(</span><span class="n">l</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="o">/^</span><span class="n">s</span><span class="o">*</span><span class="p">[</span><span class="o">^</span>#<span class="p">]</span><span class="o">*</span><span class="n">pull_request_target</span><span class="o">/</span><span class="p">.</span><span class="nf">test</span><span class="p">(</span><span class="n">l</span><span class="p">)</span><span class="p">)</span><span class="p">)</span> <span class="k">continue</span><span class="p">;</span>

  <span class="kd">const</span> <span class="n">hits</span> <span class="o">=</span> <span class="p">[</span><span class="p">]</span><span class="p">;</span>
  <span class="n">lines</span><span class="p">.</span><span class="nf">forEach</span><span class="p">(</span><span class="p">(</span><span class="n">line</span><span class="p">,</span> <span class="n">i</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="p">{</span>
    <span class="k">for</span> <span class="p">(</span><span class="kd">const</span> <span class="p">[</span><span class="n">re</span><span class="p">,</span> <span class="n">why</span><span class="p">]</span> <span class="k">of</span> <span class="n">risky</span><span class="p">)</span> <span class="p">{</span>
      <span class="k">if</span> <span class="p">(</span><span class="n">re</span><span class="p">.</span><span class="nf">test</span><span class="p">(</span><span class="n">line</span><span class="p">)</span><span class="p">)</span> <span class="n">hits</span><span class="p">.</span><span class="nf">push</span><span class="p">(</span><span class="sb">`  line ${i + 1}: ${why}`</span><span class="p">)</span><span class="p">;</span>
    <span class="p">}</span>
  <span class="p">}</span><span class="p">)</span><span class="p">;</span>

  <span class="nb">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="n">hits</span><span class="p">.</span><span class="n">length</span> <span class="o">?</span> <span class="sb">`&#x26a0;  ${file}`</span> <span class="p">:</span> <span class="sb">`•  ${file} (no PR checkout found)`</span><span class="p">)</span><span class="p">;</span>
  <span class="n">hits</span><span class="p">.</span><span class="nf">forEach</span><span class="p">(</span><span class="p">(</span><span class="n">h</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="nb">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="n">h</span><span class="p">)</span><span class="p">)</span><span class="p">;</span>
<span class="p">}</span>
</code></pre>
</div>
<p>Run it with <code>node find-prt.mjs</code>. On a test folder holding the insecure example above plus a plain labeler, it prints:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight plaintext"><code>&#x26a0;  insecure.yml
  line 11: checks out the PR head
•  labeler.yml (no PR checkout found)
</code></pre>
</div>
<p>It&#8217;s a regex pass, not a security audit. It won&#8217;t catch a script that downloads PR code some other way, so treat a clean result as &#8220;look closer at these files&#8221;, not &#8220;all good&#8221;.</p>
<p>If your account shows policy insights for Actions, check that too. It lists the runs the default rule would have blocked, which is the most accurate list you&#8217;ll get. (Some maintainers on non-Enterprise orgs report they can&#8217;t see it, which is why the grep matters.)</p>
<h2>
<p>  Step 2: decide what each workflow should become<br />
</p></h2>
<p>Every hit lands in one of three buckets.</p>
<h3>
<p>  It doesn&#8217;t need secrets → switch to <code>pull_request</code><br />
</p></h3>
<p>This is most CI. Tests, lint, type checks and builds don&#8217;t need write tokens or secrets to tell you whether a PR is green. Change the trigger and lock down permissions:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight yaml"><code><span class="na">on</span><span class="p">:</span> <span class="s">pull_request</span>

<span class="na">permissions</span><span class="p">:</span>
  <span class="na">contents</span><span class="p">:</span> <span class="s">read</span>

<span class="na">jobs</span><span class="p">:</span>
  <span class="na">test</span><span class="p">:</span>
    <span class="na">runs-on</span><span class="p">:</span> <span class="s">ubuntu-latest</span>
    <span class="na">steps</span><span class="p">:</span>
      <span class="p">-</span> <span class="na">uses</span><span class="p">:</span> <span class="s">actions/checkout@v6</span>
      <span class="p">-</span> <span class="na">run</span><span class="p">:</span> <span class="s">npm ci</span>
      <span class="p">-</span> <span class="na">run</span><span class="p">:</span> <span class="s">npm test</span>
</code></pre>
</div>
<p>That&#8217;s the whole fix for a lot of repos.</p>
<h3>
<p>  It needs secrets but never runs PR code → keep it, allow it on purpose<br />
</p></h3>
<p>Labelers, greeting bots and triage jobs often fit here. They read PR metadata and write a label or a comment, and they never check out the fork&#8217;s code. Here&#8217;s a labeler that only needs to write to the PR:
</p>
<div class="highlight js-code-highlight">
<pre class="highlight yaml"><code><span class="na">on</span><span class="p">:</span> <span class="s">pull_request_target</span>

<span class="na">permissions</span><span class="p">:</span>
  <span class="na">contents</span><span class="p">:</span> <span class="s">read</span>
  <span class="na">pull-requests</span><span class="p">:</span> <span class="s">write</span>

<span class="na">jobs</span><span class="p">:</span>
  <span class="na">label</span><span class="p">:</span>
    <span class="na">runs-on</span><span class="p">:</span> <span class="s">ubuntu-latest</span>
    <span class="na">steps</span><span class="p">:</span>
      <span class="p">-</span> <span class="na">uses</span><span class="p">:</span> <span class="s">actions/labeler@v5</span>
</code></pre>
</div>
<p>These are what the event policy exists for. Allow <code>pull_request_target</code> in an Actions event policy and use workflow file targeting so only this file gets the exception. Don&#8217;t allow it repo-wide just to keep an old workflow green. Policies can be set at the repository, organization or enterprise level. The steps are in <a href="https://docs.github.com/actions/how-tos/administer/control-workflow-execution" rel="noopener noreferrer">GitHub&#8217;s workflow execution docs</a>.</p>
<h3>
<p>  It needs to run PR code <em>and</em> use secrets → split it<br />
</p></h3>
<p>Think &#8220;build the fork&#8217;s PR, then post a comment or preview link&#8221;. Split it into two workflows:</p>
<ol>
<li>A <code>pull_request</code> workflow that builds and tests the untrusted code with no secrets, then uploads a small artifact.</li>
<li>A <code>workflow_run</code> workflow that runs after it, with the permissions it needs, and reads that artifact as <strong>data only</strong>.
</li>
</ol>
<div class="highlight js-code-highlight">
<pre class="highlight yaml"><code><span class="na">name</span><span class="p">:</span> <span class="s">PR build</span>
<span class="na">on</span><span class="p">:</span> <span class="s">pull_request</span>

<span class="na">permissions</span><span class="p">:</span>
  <span class="na">contents</span><span class="p">:</span> <span class="s">read</span>

<span class="na">jobs</span><span class="p">:</span>
  <span class="na">build</span><span class="p">:</span>
    <span class="na">runs-on</span><span class="p">:</span> <span class="s">ubuntu-latest</span>
    <span class="na">steps</span><span class="p">:</span>
      <span class="p">-</span> <span class="na">uses</span><span class="p">:</span> <span class="s">actions/checkout@v6</span>
      <span class="p">-</span> <span class="na">run</span><span class="p">:</span> <span class="s">npm ci</span>
      <span class="p">-</span> <span class="na">run</span><span class="p">:</span> <span class="s">npm run build</span>
      <span class="p">-</span> <span class="na">run</span><span class="p">:</span> <span class="s">echo "${{ github.event.pull_request.number }}" &gt; pr-number.txt</span>
      <span class="p">-</span> <span class="na">uses</span><span class="p">:</span> <span class="s">actions/upload-artifact@v4</span>
        <span class="na">with</span><span class="p">:</span>
          <span class="na">name</span><span class="p">:</span> <span class="s">pr-result</span>
          <span class="na">path</span><span class="p">:</span> <span class="s">pr-number.txt</span>
</code></pre>
</div>
<div class="highlight js-code-highlight">
<pre class="highlight yaml"><code><span class="na">name</span><span class="p">:</span> <span class="s">PR comment</span>
<span class="na">on</span><span class="p">:</span>
  <span class="na">workflow_run</span><span class="p">:</span>
    <span class="na">workflows</span><span class="p">:</span> <span class="p">[</span><span class="s2">"PR build"</span><span class="p">]</span>
    <span class="na">types</span><span class="p">:</span> <span class="p">[</span><span class="s">completed</span><span class="p">]</span>

<span class="na">permissions</span><span class="p">:</span>
  <span class="na">pull-requests</span><span class="p">:</span> <span class="s">write</span>
  <span class="na">actions</span><span class="p">:</span> <span class="s">read</span>

<span class="na">jobs</span><span class="p">:</span>
  <span class="na">comment</span><span class="p">:</span>
    <span class="na">if</span><span class="p">:</span> <span class="s">github.event.workflow_run.conclusion == 'success'</span>
    <span class="na">runs-on</span><span class="p">:</span> <span class="s">ubuntu-latest</span>
    <span class="na">steps</span><span class="p">:</span>
      <span class="p">-</span> <span class="na">uses</span><span class="p">:</span> <span class="s">actions/download-artifact@v4</span>
        <span class="na">with</span><span class="p">:</span>
          <span class="na">name</span><span class="p">:</span> <span class="s">pr-result</span>
          <span class="na">run-id</span><span class="p">:</span> <span class="s">${{ github.event.workflow_run.id }}</span>
          <span class="na">github-token</span><span class="p">:</span> <span class="s">${{ secrets.GITHUB_TOKEN }}</span>
      <span class="c1"># The artifact came from a fork. Read it as data, never run it.
</span>      <span class="p">-</span> <span class="na">name</span><span class="p">:</span> <span class="s">Comment on the PR</span>
        <span class="na">env</span><span class="p">:</span>
          <span class="na">GH_TOKEN</span><span class="p">:</span> <span class="s">${{ secrets.GITHUB_TOKEN }}</span>
          <span class="na">GH_REPO</span><span class="p">:</span> <span class="s">${{ github.repository }}</span>
        <span class="na">run</span><span class="p">:</span> <span class="p">|</span>
          <span class="s">PR=$(head -c 10 pr-number.txt)</span>
          <span class="s">if ! [[ "$PR" =~ ^[0-9]+$ ]]; then echo "bad PR number"; exit 1; fi</span>
          <span class="s">gh pr comment "$PR" --body "Build passed &#x2705;"</span>
</code></pre>
</div>
<p>The number check isn&#8217;t paranoia. The fork controls what ends up in that artifact, so the privileged workflow validates it before using it. GitHub&#8217;s docs are blunt about this: a <code>workflow_run</code> job that fetches and runs fork code has exactly the same hole as a bad <code>pull_request_target</code> job. Splitting only helps if the second half never executes anything from the first.</p>
<h2>
<p>  One more flag to grep for<br />
</p></h2>
<p>Since v7, <code>actions/checkout</code> refuses to check out fork PR refs in these privileged workflows unless you set <code>allow-unsafe-pr-checkout: true</code>. The name is meant to stand out in code review. If you find it in your repo, someone either confirmed that code is never executed, or turned the protection off to make a red build go green. Find out which.</p>
<h2>
<p>  Your checklist before December 2<br />
</p></h2>
<ul>
<li>Run the grep (or the script) on every public repo you maintain.</li>
<li>Move plain CI to <code>pull_request</code> with <code>contents: read</code>.</li>
<li>Split anything that runs PR code and needs secrets.</li>
<li>For the few workflows that truly need the trigger, add an event policy targeted at those files only.</li>
<li>Check any self-hosted runners those jobs use. GitHub&#8217;s guidance is to keep them isolated from internal resources and ephemeral.</li>
</ul>
<p>GitHub has already moved this date once, so keep an eye on the <a href="https://github.blog/changelog/2026-11-02-pull_request_target-blocked-by-default-december-2" rel="noopener noreferrer">changelog</a>. Don&#8217;t plan around it moving again, though. Most of these fixes take minutes, and the switch-to-<code>pull_request</code> case makes your CI safer even if nothing gets blocked.</p>
<p>If you&#8217;re building with AI agents that open PRs on your repos, this is worth a second look too. More of that kind of workflow on the <a href="https://www.youtube.com/@javascriptmastery" rel="noopener noreferrer">JavaScript Mastery YouTube channel</a>.</p>
<p><strong>Sources:</strong> <a href="https://github.blog/changelog/2026-11-02-pull_request_target-blocked-by-default-december-2" rel="noopener noreferrer">GitHub changelog: pull_request_target blocked by default December 2</a> · <a href="https://docs.github.com/en/actions/reference/security/securely-using-pull_request_target" rel="noopener noreferrer">Securely using pull_request_target (GitHub Docs)</a> · <a href="https://github.blog/changelog/2026-09-17-workflow-execution-protections-in-github-actions-generally-available/" rel="noopener noreferrer">Workflow execution protections GA (GitHub changelog, Sep 17)</a></p>]]></content:encoded>
					
					<wfw:commentRss>https://codango.com/pull_request_target-gets-blocked-on-dec-2-heres-a-10-minute-check/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>
