<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Fei Jihua</title>
    <description>The latest articles on DEV Community by Fei Jihua (@feijihua).</description>
    <link>https://dev.to/feijihua</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4206549%2Ffd12ac9d-2128-4927-8b43-2b0d2a0c348b.png</url>
      <title>DEV Community: Fei Jihua</title>
      <link>https://dev.to/feijihua</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/feijihua"/>
    <language>en</language>
    <item>
      <title>45.8s, then 12.6s: same prompt on Cloudflare Workers AI</title>
      <dc:creator>Fei Jihua</dc:creator>
      <pubDate>Mon, 02 Nov 2026 13:20:25 +0000</pubDate>
      <link>https://dev.to/feijihua/458s-then-126s-same-prompt-on-cloudflare-workers-ai-2333</link>
      <guid>https://dev.to/feijihua/458s-then-126s-same-prompt-on-cloudflare-workers-ai-2333</guid>
      <description>&lt;p&gt;I've been building a small tool that turns one technical post into an X thread, a LinkedIn post, a TikTok script and a newsletter blurb. It runs on Cloudflare Workers with Workers AI, on the free plan.&lt;/p&gt;

&lt;p&gt;The product part was the easy half. Getting generation to behave predictably is what took me three passes — and the first lesson was that I couldn't even trust my own stopwatch.&lt;/p&gt;

&lt;h2&gt;
  
  
  Two requests, ten minutes apart, 3.6× difference
&lt;/h2&gt;

&lt;p&gt;Both of these are real generations of the same sample post into the same two formats (a TikTok script plus a newsletter blurb), run within ten minutes of each other:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Request&lt;/th&gt;
&lt;th&gt;Wall clock&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Sample text, as shipped&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;45.8 s&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Same text, one number changed&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;12.6 s&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The only difference between them is a single character in the source. Same worker, same model, same batch, same region.&lt;/p&gt;

&lt;p&gt;I can guess at the cause — a cold isolate, a busy shared queue, or both — but I can't tell them apart from the outside. What I can state for certain is that the spread is real, and that one sample tells you nothing.&lt;/p&gt;

&lt;p&gt;(A day earlier the same batch measured 12.5 s. Same lesson, third number.)&lt;/p&gt;

&lt;p&gt;Before that, my numbers were worse than useless: my local &lt;code&gt;curl&lt;/code&gt; was resolving to an IPv6 address and hanging intermittently, producing 55–90 s results that had nothing to do with the server. Pinning &lt;code&gt;curl -4&lt;/code&gt; deleted all of them. &lt;strong&gt;Half of my first week of "performance problems" was my own tooling.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Why that spread is dangerous, not just annoying
&lt;/h2&gt;

&lt;p&gt;Cloudflare closes a request at &lt;strong&gt;100 seconds&lt;/strong&gt; — the browser gets a 524 and any work still in flight is discarded. That's wall clock, not CPU time.&lt;/p&gt;

&lt;p&gt;At 12 s per batch you have room for eight of them. At 45 s you have room for two. The same code that was comfortable on Monday is one slow queue away from a dead request on Tuesday.&lt;/p&gt;

&lt;p&gt;This is the failure mode that made me redesign the request shape: not "how do I make it faster", but "how do I stop one slow batch from taking the whole run down with it".&lt;/p&gt;

&lt;h2&gt;
  
  
  Fix 1: batch by expected duration, not by user intent
&lt;/h2&gt;

&lt;p&gt;My first version treated one run as one request — every selected format, &lt;code&gt;await Promise.all()&lt;/code&gt;. The obvious problem is that a seven-format run then lives or dies as a single 100-second bet.&lt;/p&gt;

&lt;p&gt;The browser now plans batches before sending anything. Cheap formats travel two at a time; each expensive one (X thread, LinkedIn post, long-form article) travels alone, and they're ordered so the visitor sees something usable while the slow ones are still working:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;SLOW_PLATFORMS&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="na"&gt;x&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;linkedin&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;article&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt; &lt;span class="p"&gt;};&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;BATCH_MAX&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;planBatches&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;platforms&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;groups&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[];&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;fast&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;platforms&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;filter&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="nx"&gt;p&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="nx"&gt;SLOW_PLATFORMS&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;p&lt;/span&gt;&lt;span class="p"&gt;]);&lt;/span&gt;
  &lt;span class="k"&gt;for &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="nx"&gt;i&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="nx"&gt;i&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="nx"&gt;fast&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;length&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="nx"&gt;i&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="nx"&gt;BATCH_MAX&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;groups&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;push&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;fast&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;slice&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;i&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;i&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nx"&gt;BATCH_MAX&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
  &lt;span class="c1"&gt;// Sorted by weight so X lands before LinkedIn and the article comes last:&lt;/span&gt;
  &lt;span class="c1"&gt;// the visitor should see something usable while the slow ones are working.&lt;/span&gt;
  &lt;span class="nx"&gt;platforms&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;filter&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="nx"&gt;p&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nx"&gt;SLOW_PLATFORMS&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;p&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;sort&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="nx"&gt;a&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nx"&gt;SLOW_PLATFORMS&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;a&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="nx"&gt;SLOW_PLATFORMS&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;b&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;forEach&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="nx"&gt;p&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nx"&gt;groups&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;push&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="nx"&gt;p&lt;/span&gt;&lt;span class="p"&gt;]));&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nx"&gt;groups&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The cost is honesty about time: seven formats become five sequential requests, so the UI shows "batch 3 of 5" instead of one spinner. I'd rather show a number than show nothing.&lt;/p&gt;

&lt;h2&gt;
  
  
  Fix 2: one retry, with a reason
&lt;/h2&gt;

&lt;p&gt;A single timeout shouldn't be a failed run. The same payload gets exactly one more attempt, and the user is told why they're waiting:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;postBatch&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;async &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;headers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;batch&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;label&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;attempt&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;ctl&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;AbortController&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;timer&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;setTimeout&lt;/span&gt;&lt;span class="p"&gt;(()&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nx"&gt;ctl&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;abort&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="mi"&gt;90000&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;fetch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;/repurpose&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="na"&gt;method&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;POST&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;headers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;signal&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;ctl&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;signal&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="na"&gt;body&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;JSON&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;stringify&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt; &lt;span class="nx"&gt;text&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;platforms&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;batch&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;tone&lt;/span&gt; &lt;span class="p"&gt;})&lt;/span&gt;
    &lt;span class="p"&gt;}).&lt;/span&gt;&lt;span class="nf"&gt;then&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="nx"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nx"&gt;r&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;json&lt;/span&gt;&lt;span class="p"&gt;()).&lt;/span&gt;&lt;span class="k"&gt;finally&lt;/span&gt;&lt;span class="p"&gt;(()&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nf"&gt;clearTimeout&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;timer&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;
  &lt;span class="p"&gt;};&lt;/span&gt;
  &lt;span class="k"&gt;try&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;attempt&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;catch &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;e&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;transient&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;e&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;e&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;name&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;AbortError&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nx"&gt;e&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;name&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;TypeError&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="nx"&gt;transient&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;throw&lt;/span&gt; &lt;span class="nx"&gt;e&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nx"&gt;hint&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;textContent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;`Queue was busy on &lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;label&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt; — retrying once…`&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;attempt&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;};&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The retry only fires on transient failures. A &lt;code&gt;4xx&lt;/code&gt; quota refusal is &lt;em&gt;not&lt;/em&gt; retried — repeating it just burns quota twice and reports the same thing.&lt;/p&gt;

&lt;h2&gt;
  
  
  What actually made it fast
&lt;/h2&gt;

&lt;p&gt;Both fixes above are damage control. The real win came from an uncomfortable observation:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;the most expensive prompt in my product was also the most repeated one.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The "try an example" button sends a fixed sample post with fixed formats. Those requests are byte-identical every single time — and every one of them was paying for a fresh 70B inference.&lt;/p&gt;

&lt;p&gt;So generation now goes through Cloudflare's AI Gateway, which caches at the edge. It's free on every plan:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;r&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nx"&gt;env&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;AI&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;MODEL&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;inputs&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="na"&gt;gateway&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="na"&gt;id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;default&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;skipCache&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;cacheTtl&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;3600&lt;/span&gt; &lt;span class="p"&gt;},&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Same payload, measured before and after:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Run&lt;/th&gt;
&lt;th&gt;Wall clock&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;First run (real generation)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;45.8 s&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Second run (cache hit)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;2.83 s&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Third run, after a redeploy&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;2.59 s&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;All three returned byte-identical output — which is itself the proof, since &lt;code&gt;temperature: 0.7&lt;/code&gt; cannot produce the same text twice by accident.&lt;/p&gt;

&lt;p&gt;Two things I'd have wanted to know first:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;id: 'default'&lt;/code&gt; creates the gateway on your first authenticated request. No dashboard step, no extra API token.&lt;/li&gt;
&lt;li&gt;The cache key is a hash of the full request body, so it only helps when the input is truly identical. I checked the negative case too: changing one number in the source produced a fresh generation (12.6 s) with the corrected number in the output.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Three things I'd tell myself earlier
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Measure twice, and pin your transport.&lt;/strong&gt; My worst numbers were my own tooling, not the server. &lt;code&gt;curl -4&lt;/code&gt; turned a phantom 90-second stall into a real 6-second call.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;On a shared queue, latency belongs to the platform, not to your code.&lt;/strong&gt; Design for the spread, not for the average.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cache the demo, not the product.&lt;/strong&gt; Real inputs are unique. The button people click repeatedly is where your quota actually goes.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The tool is free and needs no card, if you'd rather see the output than read about it: &lt;a href="https://feijihua.top" rel="noopener noreferrer"&gt;https://feijihua.top&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;And the honest limit: it produces a skeleton, not your voice. I rewrote the opening line of the LinkedIn draft it gave me. That's the deal with a 70B model on a free queue.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>performance</category>
      <category>javascript</category>
      <category>webdev</category>
    </item>
    <item>
      <title>Why most AI writing tools mangle your code</title>
      <dc:creator>Fei Jihua</dc:creator>
      <pubDate>Tue, 27 Oct 2026 14:13:18 +0000</pubDate>
      <link>https://dev.to/feijihua/why-most-ai-writing-tools-mangle-your-code-14af</link>
      <guid>https://dev.to/feijihua/why-most-ai-writing-tools-mangle-your-code-14af</guid>
      <description>&lt;p&gt;You paste in a blog post with a &lt;code&gt;git rebase -i&lt;/code&gt; walkthrough, one config snippet, and a benchmark table. What comes back is a "thread" that reads like a growth marketer found your draft: the command turned into "streamline your workflow", the snippet vanished, and there's a number you never wrote — apparently your setup is now "10x faster".&lt;/p&gt;

&lt;p&gt;The shape of it, roughly every time:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;in:   git rebase -i origin/main
      docker run -p 8080:80 target/release/api
      p95: 840ms → 210ms

out:  Streamline your CI workflow!
      Your setup is now 10x faster.  (thread 1/3)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If you write technical content, you've lived some version of this. After one or two of these, most of us quietly go back to writing everything by hand, and the tool gets filed under "demo only".&lt;/p&gt;

&lt;p&gt;The problem isn't that these tools write badly. They're bad at &lt;strong&gt;not rewriting&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Three reasons it happens
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. The objective is "engaging", not "faithful"
&lt;/h3&gt;

&lt;p&gt;Nearly every repurposing tool is built on the same instruction: "turn this into an engaging social post." That objective comes from the marketing playbook — hook first, punchy, scannable. Code blocks are the enemy of scannable. Flags are the enemy of punchy. So the model does exactly what it was asked to do: it optimizes for engagement and pays for it with your technical content.&lt;/p&gt;

&lt;p&gt;Nobody told it "the code is the point", so it treats the code as filler.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Compression is the model's default instinct
&lt;/h3&gt;

&lt;p&gt;Ask an LLM to "simplify" anything and it compresses — that is what it is good at. In a technical post, the highest-density tokens are the code, the flags, the version numbers, and those are exactly what a summarizer eats first. &lt;code&gt;docker run -p 8080:80&lt;/code&gt; becomes "run the container". Technically fine. Completely useless to the reader who came for the command.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Nothing anchors the output to the source
&lt;/h3&gt;

&lt;p&gt;Worse than a deleted snippet is an invented one. Left unconstrained, the model fills gaps with plausible-sounding facts: benchmarks you never ran, quotes you never gave, versions that don't exist. A wrong flag in a tutorial is worse than no tutorial — someone pastes it into prod at 2am and blames you.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why this hurts technical content specifically
&lt;/h2&gt;

&lt;p&gt;A marketing post that is 80% faithful is still publishable. A technical post that is 80% faithful is dangerous, because readers don't skim your post for vibes — they copy-paste from it. One mangle and the tool is dead to you.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I did about it — and what it does not fix
&lt;/h2&gt;

&lt;p&gt;I hit this often enough to build ReThread. The honest framing: I can't change how the model behaves. What I can do is put constraints around it, plus one check that is a mitigation, not a guarantee.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. The source is fenced and marked untouchable.&lt;/strong&gt; Every request wraps your input:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;SOURCE CONTENT (rewrite this, do not add new claims):
"""
&amp;lt;your post&amp;gt;
"""
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The model isn't invited to improve your post. It's told to rewrite &lt;em&gt;this&lt;/em&gt; and add nothing to it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. The rules are constraints, not suggestions:&lt;/strong&gt; preserve code, commands and domain terms; never invent facts, stats or quotes; no emoji spam, no clickbait.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Every platform spec repeats the accuracy rule.&lt;/strong&gt; "Keep it under 280 characters" and "keep the code" pull in opposite directions, so the model has to hear both at once, per platform.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4. A preservation check that retries once.&lt;/strong&gt; Before generating, the code extracts the source's code assets (fenced blocks plus inline code). After generating, it measures how many survived — matched case- and whitespace-insensitively, so a re-wrapped code block still counts but a renamed variable does not. If the source had 2+ assets and fewer than half survived, it regenerates once at low temperature with an explicit "you dropped code, keep it verbatim" instruction, then keeps whichever attempt scored higher.&lt;/p&gt;

&lt;p&gt;That last one is the part I'd flag to anyone building the same thing: it only sees code blocks and inline code. It does not see version numbers, benchmark figures, or what was inside a table. On my own test posts it kept every asset — that is a handful of samples, not a benchmark.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where it still breaks
&lt;/h2&gt;

&lt;p&gt;So you don't find out the hard way:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Long posts get truncated.&lt;/strong&gt; Input is capped at 20,000 characters.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;TikTok scripts drop code on purpose.&lt;/strong&gt; A 60-second talking-head script can't read a &lt;code&gt;yaml&lt;/code&gt; block out loud. It names the command or flag verbally instead ("the &lt;code&gt;--force&lt;/code&gt; flag I cover in the post"). If you need verbatim code, use the X / LinkedIn / article formats.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The model is Llama 3.3 70B on Cloudflare Workers AI.&lt;/strong&gt; Not the strongest model available. It keeps the demo free and fast; a frontier model would hold up better on long, dense posts. Read the output before you publish it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Numbers and tables are not checked&lt;/strong&gt; by the preservation pass.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It writes English.&lt;/strong&gt; A post in another language comes back translated into English. I tested this with Chinese: the facts, the commands and the numbers survived, the language did not. Treat it as English-only for now.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It produces text only.&lt;/strong&gt; No scheduling, no auto-posting, no images. You still paste the result into each platform yourself.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Free is 70 platform calls a day with an email&lt;/strong&gt; — no card, no password. A run on two formats costs 2 calls, so that is up to 35 two-format runs, or 10 runs on all seven. Without an email you get 15 calls a day (about 7 two-format runs), shared by everyone behind the same IP, and nothing is saved to your history.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Use it if / don't use it if
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Reasonable fit:&lt;/strong&gt; you already wrote the long post and need it reformatted for 2–4 platforms; you will read the output before posting it (you should, always).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Bad fit:&lt;/strong&gt; you want it to write the post for you; you need guaranteed fidelity on dense numeric content; you want publishing automation; you write in a language other than English.&lt;/p&gt;

&lt;h2&gt;
  
  
  The bar for technical AI tools
&lt;/h2&gt;

&lt;p&gt;If you're building for developers, here is the uncomfortable part: &lt;strong&gt;we don't grade on a curve.&lt;/strong&gt; Nobody wants a tool that is "mostly right". We want one trustworthy enough that we stop re-reading every line. That is a much higher bar than "sounds engaging", and it is a prompting and evaluation problem as much as a model-size problem.&lt;/p&gt;

&lt;p&gt;So, honest question for the comments: what is the worst AI-mangling you've run into? Stripped code blocks, invented benchmarks, "simplified" commands that no longer run?&lt;/p&gt;

&lt;p&gt;ReThread is at &lt;a href="https://feijihua.top" rel="noopener noreferrer"&gt;https://feijihua.top&lt;/a&gt; — free while it is in beta: an email gets you 70 platform calls a day (a run on two formats costs 2 calls, so 35 two-format runs, or 10 runs on all seven), and brand-voice matching is included — there is no paid tier right now. It is a one-person project, so the honest status is: the parts above work, and the list of what it does not do is the rest of this post.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>webdev</category>
      <category>discuss</category>
    </item>
    <item>
      <title>How I built a $0/month AI SaaS on Cloudflare (Pages + Workers AI + KV)</title>
      <dc:creator>Fei Jihua</dc:creator>
      <pubDate>Mon, 26 Oct 2026 13:03:28 +0000</pubDate>
      <link>https://dev.to/feijihua/how-i-built-a-0month-ai-saas-on-cloudflare-pages-workers-ai-kv-18gd</link>
      <guid>https://dev.to/feijihua/how-i-built-a-0month-ai-saas-on-cloudflare-pages-workers-ai-kv-18gd</guid>
      <description>&lt;p&gt;The goal&lt;br&gt;
I wanted to ship a real SaaS product — one that calls an LLM, takes money, has auth, and reaches a global audience — without spinning up a server, managing a database, or paying infra bills before I had a single customer.&lt;br&gt;
So I built ReThread (an AI tool that turns one technical blog post into 7 platform-native formats) entirely on Cloudflare's free tiers. This post is the architecture, the tradeoffs, and what I'd tell you if you're building something similar.&lt;br&gt;
The whole stack on one platform&lt;br&gt;
No servers, no Docker, no separate API host. Everything lives in one Cloudflare project:&lt;br&gt;
┌──────────────────────────────────────────────┐&lt;br&gt;
│           Cloudflare Pages project            │&lt;br&gt;
│                                              │&lt;br&gt;
│   public/     →  static frontend (HTML/JS)    │&lt;br&gt;
│   functions/  →  serverless API endpoints     │&lt;br&gt;
│                                              │&lt;br&gt;
│   Bindings:                                  │&lt;br&gt;
│     AI       →  Workers AI (Llama 3.3 70B)    │&lt;br&gt;
│     WAITLIST →  KV (key-value store)          │&lt;br&gt;
└──────────────────────────────────────────────┘&lt;br&gt;
         │                        │&lt;br&gt;
    Creem (payments)      Global edge (300+ cities)&lt;br&gt;
One wrangler pages deploy ships the frontend AND the API together. That alone removed most of the usual "wire up a backend" yak-shaving.&lt;br&gt;
The pieces that do the real work&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Pages Functions as the API
Each file in functions/ is an endpoint. functions/repurpose.js exports an onRequestPost that takes the user's post, calls the LLM, and returns the formats you asked for. No framework, no Express — just a function per route.
This is what surprised me most: the "backend" is just a folder of files that deploys alongside the static site.&lt;/li&gt;
&lt;li&gt;Workers AI for inference
The LLM call is a single binding — no API keys, no separate provider account:
const result = await env.AI.run(
"&lt;a class="mentioned-user" href="https://dev.to/cf"&gt;@cf&lt;/a&gt;/meta/llama-3.3-70b-instruct-fp8-fast",
{ messages: [ /* ... */ ] }
);
It runs on Cloudflare's GPUs at the edge, so a user in São Paulo and a user in Berlin both hit a nearby node. The free tier has a daily allocation that's plenty at low volume — no credit card required.
(Swappable: if you ever want GPT-4-class quality, the same code path can call OpenAI/DeepSeek via an env var.)&lt;/li&gt;
&lt;li&gt;KV as the entire "database"
No Postgres, no Redis. KV holds:&lt;/li&gt;
&lt;li&gt;Entitlements — who paid, what plan, active/refunded&lt;/li&gt;
&lt;li&gt;Sessions — passwordless login tokens (7-day TTL)&lt;/li&gt;
&lt;li&gt;License keys — the key → email mapping&lt;/li&gt;
&lt;li&gt;Rate-limit counters — per-user daily usage, charged before the model runs&lt;/li&gt;
&lt;li&gt;Page-view counters — referrer attribution, so I know which channel sent traffic
KV is a globally-replicated key-value store. Reads are fast everywhere; writes are eventually consistent (usually under a minute to propagate). For entitlements and counters that's totally fine. I would NOT use it for anything needing strong consistency (inventory, ledgers).
Update (Oct 2026): the paid path described in the next two sections is switched off. ReThread is free during the beta — no card, no paid plan. The code is still there (webhook, license keys, entitlement checks), just unused. I left these sections in because the HMAC and event de-duplication pattern is the part actually worth reading.&lt;/li&gt;
&lt;li&gt;Passwordless auth + a license key
Two ways to unlock the paid tier:&lt;/li&gt;
&lt;li&gt;License key: Creem emails the buyer a key on purchase; they paste it in the app. The webhook stores key → {email, plan} in KV.&lt;/li&gt;
&lt;li&gt;Email fallback: the webhook already verified the payment, so the purchase email unlocks Pro directly.
Sessions are a random UUID stored in KV with a 7-day TTL — no password table, no bcrypt, no reset-flow emails. And entitlement is re-checked on every request, so a refund or cancel instantly revokes access (no "you still have Pro for 7 days" loophole).
One detail worth borrowing: the API never trusts an email in the request body. Identity comes from the session token, and the body's email is only used as a display label. Otherwise anyone can spend someone else's quota by typing their address.&lt;/li&gt;
&lt;li&gt;Verifying the payment webhook
Creem hits /webhook on every purchase/refund. I verify the HMAC-SHA256 signature before trusting anything, and de-dupe by event ID in KV so a redelivered event can't double-grant. Then it's a simple KV write to flip the entitlement.
What it actually costs
Service
Free tier
Cost at my volume
Pages + Functions
Unlimited requests, 500 builds/mo
$0
Workers AI
Daily free allocation
$0
KV
~100k reads / 1k writes per day
$0
Creem
—
n/a during beta (paid tier off)
&lt;strong&gt;Total: $0/month&lt;/strong&gt; — and it stayed $0 with zero users, which is the whole point. The first bill only shows up after there is real traffic, and that is exactly the order you want.
(Free-tier numbers change; check Cloudflare's current limits. But the shape holds: you get a lot for free.)
Tradeoffs / what I'd tell you&lt;/li&gt;
&lt;li&gt;KV's eventual consistency is the main gotcha — don't build anything that needs read-after-write guarantees across regions.&lt;/li&gt;
&lt;li&gt;Workers have limits (CPU time, subrequests). Fine for API endpoints; don't try to run a video transcode.&lt;/li&gt;
&lt;li&gt;There is a 100-second gateway timeout, and it is closer than you think. A 7-format run takes about 100 seconds of model time in total, so firing all 7 requests in parallel reliably returns a 524 — after the quota has already been charged. The fix was boring: the frontend sends three batches and stitches the results. Now the worst batch is about 40 seconds. I shipped the broken version first.&lt;/li&gt;
&lt;li&gt;Plan for the free allocation running out. My global cap is 150 model calls a day, so on a good day the demo says "at capacity, come back tomorrow" instead of throwing random per-request errors. Degrading on purpose beats failing by accident.&lt;/li&gt;
&lt;li&gt;One platform = one blast radius. If Cloudflare has a bad day, your whole stack is down. Acceptable for a side project; for something mission-critical I'd diversify.&lt;/li&gt;
&lt;li&gt;The DX is genuinely great. wrangler pages deploy and you're live globally. I shipped this in a weekend of evenings.
The product, if you're curious
ReThread → &lt;a href="https://feijihua.top" rel="noopener noreferrer"&gt;https://feijihua.top&lt;/a&gt; — turn one technical post into 7 formats without mangling your code. Free during the beta: 10 full runs a day with an email, no card, brand-voice matching included.
Built it partly to scratch my own itch and partly to prove you can ship a real AI SaaS — payments wired end to end, auth, quota, webhooks — without paying for infrastructure. Happy to answer questions in the comments — especially if you're building something similar on Workers.&lt;/li&gt;
&lt;/ol&gt;

</description>
      <category>cloudflarechallenge</category>
      <category>webdev</category>
      <category>ai</category>
      <category>architecture</category>
    </item>
    <item>
      <title>I built ReThread: repurpose a technical post into 7 formats without mangling your code</title>
      <dc:creator>Fei Jihua</dc:creator>
      <pubDate>Sun, 25 Oct 2026 13:01:01 +0000</pubDate>
      <link>https://dev.to/feijihua/i-built-rethread-repurpose-a-technical-post-into-7-formats-without-mangling-your-code-1ml8</link>
      <guid>https://dev.to/feijihua/i-built-rethread-repurpose-a-technical-post-into-7-formats-without-mangling-your-code-1ml8</guid>
      <description>&lt;h2&gt;
  
  
  The problem
&lt;/h2&gt;

&lt;p&gt;Every content-repurposing tool I tried would mangle technical content: strip code&lt;br&gt;
blocks, "simplify" away the commands, and make engineers sound like marketers.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I built
&lt;/h2&gt;

&lt;p&gt;ReThread takes ONE long-form technical post (blog / README / talk transcript) and&lt;br&gt;
rewrites it into 7 native formats:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;X thread&lt;/li&gt;
&lt;li&gt;LinkedIn post&lt;/li&gt;
&lt;li&gt;TikTok script&lt;/li&gt;
&lt;li&gt;Newsletter blurb&lt;/li&gt;
&lt;li&gt;Mastodon toot&lt;/li&gt;
&lt;li&gt;Discord message&lt;/li&gt;
&lt;li&gt;Long-form article&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;...preserving your code, commands, and technical accuracy — in a direct, non-hype tone.&lt;/p&gt;

&lt;p&gt;The Pro tier adds brand-voice: paste 2-5 of your own posts and it mimics your&lt;br&gt;
writing style on every generation.&lt;/p&gt;

&lt;h2&gt;
  
  
  Stack
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Cloudflare Pages (frontend)&lt;/li&gt;
&lt;li&gt;Workers AI (Llama 3.3, swappable to OpenAI/DeepSeek)&lt;/li&gt;
&lt;li&gt;Cloudflare KV (storage)&lt;/li&gt;
&lt;li&gt;Creem (payments)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Essentially $0 infra at low volume.&lt;/p&gt;

&lt;p&gt;Free tier is 10 generations/day, no account needed.&lt;/p&gt;

&lt;p&gt;👉 &lt;a href="https://feijihua.top" rel="noopener noreferrer"&gt;https://feijihua.top&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Would love your feedback — especially on output quality for technical content!&lt;/p&gt;

</description>
      <category>showdev</category>
      <category>webdev</category>
      <category>cloudflarechallenge</category>
      <category>ai</category>
    </item>
  </channel>
</rss>
