<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sai Gavaskar Sakalam on Medium]]></title>
        <description><![CDATA[Stories by Sai Gavaskar Sakalam on Medium]]></description>
        <link>https://medium.com/@ssaigavaskar?source=rss-d6d6a9d04fac------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*lQtIvFOYYxZOm8hIo468gA.jpeg</url>
            <title>Stories by Sai Gavaskar Sakalam on Medium</title>
            <link>https://medium.com/@ssaigavaskar?source=rss-d6d6a9d04fac------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 08:35:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ssaigavaskar/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Unfair Split: Guides and Sensors for AI Agents]]></title>
            <link>https://medium.com/@ssaigavaskar/the-unfair-split-guides-and-sensors-for-ai-agents-37ae30bbfee8?source=rss-d6d6a9d04fac------2</link>
            <guid isPermaLink="false">https://medium.com/p/37ae30bbfee8</guid>
            <category><![CDATA[harness-engineering]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Sai Gavaskar Sakalam]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 20:42:48 GMT</pubDate>
            <atom:updated>2026-11-11T20:42:48.217Z</atom:updated>
            <content:encoded><![CDATA[<p>Part 1’s test passed. The split was still unfair. Here is the simple map that fixes problems like this.</p><figure><img alt="Title “The Unfair Split” above four boxes: computational guide, computational sensor, inferential guide, inferential sensor. Below it, the line “Guides steer before. Sensors check after.”" src="https://cdn-images-1.medium.com/max/1024/1*nNu6Eq_WpG0kav9jK8nQxw.png" /><figcaption>Part 2 of Harness Engineering From Scratch.</figcaption></figure><p>This is Part 2 of my series <strong>Harness Engineering From Scratch</strong>. In <a href="https://medium.com/@ssaigavaskar/the-missing-cent-a-beginners-guide-to-harness-engineering-d003f92a706a">Part 1</a>, we found a missing cent and fixed it with one rule and one test. If you are new here, start there.</p><h3>The test passed. The split was still unfair.</h3><p>In Part 1, our Split the Bill app had one test:</p><p><strong>Everyone’s shares must add up to the total.</strong></p><p>It caught the missing cent. I was happy.</p><p>Then I tried a different version of the split. It looks right, it runs, and it gives the first person all the leftover cents:</p><pre>def split_bill(total_cents, people):<br>    base, leftover = divmod(total_cents, people)<br>    # The first person pays all the leftover cents<br>    return [base + leftover] + [base] * (people - 1)</pre><p>Seven friends, a $100 bill:</p><pre>Shares: [&#39;$14.32&#39;, &#39;$14.28&#39;, &#39;$14.28&#39;, &#39;$14.28&#39;, &#39;$14.28&#39;, &#39;$14.28&#39;, &#39;$14.28&#39;]<br>Total paid: $100.00</pre><p>The total is perfect. So the Part 1 test is happy:</p><pre>.                                                                        <br>[100%]<br>1 passed in 0.00s</pre><p>But look at Friend 1. They pay 4 cents more than everyone else. Every single dinner. Forever.</p><p>Only 4 cents, yes. But imagine this app splitting rent, or office lunches, or a group trip. It is always the same person paying extra, and <strong>nothing in our project even checks for fairness</strong>.</p><figure><img alt="Seven boxes show what seven friends pay. Friend 1, in red, pays $14.32. Friends 2 to 7 pay $14.28 each. Below, “Total paid: $100.00”. A green box “Part 1 test: shares add up?” has a green tick. A red box says “Fair? No. Nothing checks it.”" src="https://cdn-images-1.medium.com/max/1024/1*wdZ_vucdKAnrGFYDUx44pQ.png" /><figcaption>The total adds up, so the Part 1 test passes. But Friend 1 pays extra, and nothing checks fairness.</figcaption></figure><p>An AI agent could easily write this. It is short, it runs, and the only test passes. If I only look at green ticks, I would merge it.</p><p>This taught me something: <strong>one test is not a harness.</strong> I needed a way to think about <em>all</em> the checks a project needs. That is what this part is about.</p><h3>The idea: help before, checks after</h3><p>Think about learning to drive.</p><p><strong>Before</strong> you drive, you get help:</p><ul><li><strong>Road signs.</strong> Same sign, same message, for every driver.</li><li><strong>Your instructor’s tips.</strong> “Slow down near schools.”</li></ul><p><strong>After</strong> you drive, someone checks you:</p><ul><li><strong>A speed camera.</strong> A machine. Fast, and it gives the same answer every time.</li><li><strong>A driving examiner.</strong> A person who watches you and uses judgement. Slower, but they notice things a camera never could, like “you didn’t look before changing lanes.”</li></ul><figure><img alt="Two panels. “Before you drive” holds Road signs (same message for every driver) and Instructor’s tips (“Slow down near schools”). “After you drive” holds Speed camera (a machine, fast, same answer every time) and Driving examiner (a person’s judgement, slower but sees the big picture). Bottom line: Guides help before. Sensors check after." src="https://cdn-images-1.medium.com/max/1024/1*xU4Lu46V3pGa_RvsL-tJNQ.png" /><figcaption>When learning to drive, some things help you before you drive, and some check you after.</figcaption></figure><p>A good driving school uses all four. Signs alone don’t stop speeding. Cameras alone don’t teach you how to drive well.</p><p>AI agents need the same thing.</p><h3>The real version: guides and sensors</h3><p>While studying, the clearest explanation I found is from <strong>Birgitta Böckeler</strong> at Thoughtworks, in her article “Harness engineering for coding agent users” on martinfowler.com (April 2026). She sorts every part of a harness by asking <strong>two questions</strong>.</p><h3>Question 1: Does it act before or after?</h3><ul><li>A <strong>guide</strong> steers the agent <strong>before</strong> it writes code. The goal is to make it more likely the agent gets it right the first time. She calls this <em>feedforward</em>.</li><li>A <strong>sensor</strong> checks the work <strong>after</strong> the agent writes code, so the agent can see what went wrong and fix it. She calls this <em>feedback</em>.</li></ul><p>Her key point stuck with me. If you only have sensors, the agent keeps making the same mistakes, because nobody told it the rules up front. If you only have guides, the agent gets rules, but nobody ever checks if it followed them.</p><p><strong>You need both.</strong></p><h3>Question 2: Who does the checking?</h3><ul><li><strong>Computational:</strong> plain code does it. Tests, linters, type checkers. These are fast (milliseconds to seconds) and give the same answer every time.</li><li><strong>Inferential:</strong> an AI does it, using judgement. For example, an AI reviewer reading your code, or “LLM as judge,” where one AI grades another’s work. This is slower, costs more, and may not give the same answer every time. But it understands <em>meaning</em>, which plain code cannot.</li></ul><p>Quick word check: a <strong>linter</strong> is a tool that reads your code and flags common mistakes and style problems automatically. <strong>Inferential</strong> just means “based on reasoning,” like how you <em>infer</em> that someone is upset from their face.</p><h3>Put the two questions together</h3><p>Two questions with two answers each give you <strong>four boxes</strong>:</p><figure><img alt="A two-by-two grid. Columns: Guide (steers before) and Sensor (checks after). Rows: Computational (plain code, fast, same every time) and Inferential (AI judgement, understands meaning). Computational guide: ready-made code like helpers, templates and code-change tools. Computational sensor: tests and linters, type checks, structure checks. Inferential guide: written rules like AGENTS.md and coding conventions. Inferential sensor: AI review, a reviewer agent, LLM as judge." src="https://cdn-images-1.medium.com/max/1024/1*ItAYD5Px9ZNy_W3QPURGyw.png" /><figcaption>Every part of a harness fits in one of four boxes.</figcaption></figure><ul><li><strong>Computational guide:</strong> ready-made code the agent can use instead of writing its own. Böckeler’s example is a code-change tool with ready-made recipes. A simpler version is a set of helper functions.</li><li><strong>Inferential guide:</strong> written rules the AI reads and understands, like the AGENTS.md file from Part 1.</li><li><strong>Computational sensor:</strong> tests, linters, type checks.</li><li><strong>Inferential sensor:</strong> an AI reviewer that judges the work.</li></ul><p>Now map Part 1 onto this. We had <strong>one inferential guide</strong> (AGENTS.md) and <strong>one computational sensor</strong> (the sum test). Two boxes were empty. And the sum test only checked one thing.</p><p>No wonder the unfair split got through.</p><h3>Real example: one rule, four ways to protect it</h3><p>Let’s take one rule and protect it from all four sides:</p><p><strong>Every cent is paid, and the split is fair.</strong></p><figure><img alt="The rule “every cent is paid, and the split is fair” sits above a two-by-two grid. Computational guide: money.py with to_cents() and format_cents(). Computational sensor: fairness test, nobody pays more than 1 cent extra. Inferential guide: AGENTS.md, “Splits must be fair”. Inferential sensor: REVIEW.md, “Would every friend feel this is fair?”" src="https://cdn-images-1.medium.com/max/1024/1*zJC5Ku3BMG7vAx5nBlLgiQ.png" /><figcaption>The same rule, protected by a guide and a sensor of each kind.</figcaption></figure><h3>Box 1: Computational guide, money.py</h3><p>Here is a trap I didn’t know about until I tried it. Say someone enters a price of $19.99, and the code turns it into cents the “obvious” way:</p><p>python</p><pre>print(19.99 * 100)<br>print(int(19.99 * 100))</pre><p>Output:</p><pre>1998.9999999999998<br>1998</pre><p><strong>1998 cents, not 1999.</strong> Another missing cent, from a different place!</p><p>This happens because decimal numbers (floats) are not exact in Python, as we saw in Part 1. An agent writing its own money math could fall into this trap again and again.</p><p>So instead of hoping the agent remembers, we give it <strong>ready-made, correct helpers</strong> to use:</p><pre># money.py<br>from decimal import Decimal<br><br><br>def to_cents(amount: str) -&gt; int:<br>    &quot;&quot;&quot;Turn a money string like &quot;19.99&quot; into whole cents (1999).<br><br>    Takes a string, not a float, because floats are not exact.<br>    &quot;&quot;&quot;<br>    cents = Decimal(amount) * 100<br>    if cents != cents.to_integral_value():<br>        raise ValueError(f&quot;{amount!r} has more than 2 decimal places&quot;)<br>    return int(cents)<br><br><br>def format_cents(cents: int) -&gt; str:<br>    &quot;&quot;&quot;Turn whole cents (1999) into a string like &quot;$19.99&quot;.&quot;&quot;&quot;<br>    sign = &quot;-&quot; if cents &lt; 0 else &quot;&quot;<br>    cents = abs(cents)<br>    return f&quot;{sign}${cents // 100}.{cents % 100:02d}&quot;</pre><p>Decimal is Python&#39;s built-in type for exact decimal numbers. It is made for money.</p><pre>from money import to_cents<br>print(to_cents(&quot;19.99&quot;))</pre><p>Output:</p><pre>1999</pre><p>Exact. This is a <strong>guide</strong> because it steers the agent <em>before</em> it writes money code. And it is <strong>computational</strong> because it is plain code, and it gives the same correct answer every time.</p><h3>Box 2: Inferential guide, AGENTS.md</h3><p>We update the rules file from Part 1. Two new lines point the agent to the helpers and add the fairness rule:</p><pre># AGENTS.md<br><br>Guide for AI coding agents working on this project.<br><br>## Money rules<br>- Always store money as whole cents (int), never float.<br>  Example: $100.00 is 10000.<br>- Never write your own money math. Use the helpers in `money.py`:<br>  `to_cents(&quot;19.99&quot;)` to read money, `format_cents(1999)` to show it.<br>- When splitting, every cent must be paid by someone.<br>  The shares must always add up to the exact total.<br>- Splits must be fair: nobody pays more than 1 cent more than anyone else.<br><br>## Before you finish<br>- Run `python -m pytest` after every change. All tests must pass.<br>- Review your change against `REVIEW.md`.</pre><p>This is <strong>inferential</strong> because the agent has to <em>read and understand</em> it. Nothing forces the agent to follow it. That is why we also need sensors.</p><h3>Box 3: Computational sensor, the fairness test</h3><p>What does “fair” mean in code? Here’s the simplest version I could think of:</p><p><strong>The person who pays the most pays at most 1 cent more than the person who pays the least.</strong></p><pre>from split_bill import split_bill<br><br>def test_nobody_pays_more_than_one_extra_cent():<br>    shares = split_bill(10000, 7)<br>    assert max(shares) - min(shares) &lt;= 1, (<br>        f&quot;Unfair split {shares}. Give leftover cents out one each, &quot;<br>        &quot;not all to one person.&quot;<br>    )</pre><p>Run it against the unfair version from the start of this article:</p><pre>F                                                                        [100%]<br>=================================== FAILURES ===================================<br>__________________ test_nobody_pays_more_than_one_extra_cent ___________________<br><br>    def test_nobody_pays_more_than_one_extra_cent():<br>        shares = split_bill(10000, 7)<br>&gt;       assert max(shares) - min(shares) &lt;= 1, (<br>            f&quot;Unfair split {shares}. Give leftover cents out one each, &quot;<br>            &quot;not all to one person.&quot;<br>        )<br>E       AssertionError: Unfair split [1432, 1428, 1428, 1428, 1428, 1428, 1428]. Give leftover cents out one each, not all to one person.<br>E       assert (1432 - 1428) &lt;= 1<br>E        +  where 1432 = max([1432, 1428, 1428, 1428, 1428, 1428, ...])<br>E        +  and   1428 = min([1432, 1428, 1428, 1428, 1428, 1428, ...])<br><br>test_fair.py:5: AssertionError<br>=========================== short test summary info ============================<br>FAILED test_fair.py::test_nobody_pays_more_than_one_extra_cent - AssertionErr...<br>1 failed in 0.01s</pre><p>Caught.</p><p>Look closely at the error message. It doesn’t just say “assertion failed.” It says <strong>what is wrong</strong> (“Unfair split [1432, 1428, …]”) and <strong>how to fix it</strong> (“Give leftover cents out one each”). Böckeler suggests exactly this: write sensor messages so the agent can use them to fix its own mistake. It’s a tiny change, and it turns a test from a red light into a hint.</p><p>In the repo, the real version of this test checks five different bills (including tiny ones like 1 cent split between 2 people), not just one.</p><h3>Box 4: Inferential sensor, REVIEW.md</h3><p>Some things are hard to check with plain code. Is the error message friendly? Is the code easy for a beginner to read? Would a real person <em>feel</em> the split is fair?</p><p>For those, we write a review checklist. A human or an AI reviewer reads the change and answers each question:</p><p>markdown</p><pre># REVIEW.md<br><br>Checklist for reviewing any change to this project.<br>A human or a review agent reads the change and answers each question.<br><br>1. **Fair:** Would every friend feel the split is fair? Could the same<br>   person end up paying extra every time?<br>2. **Clear errors:** If someone types something wrong (0 people, &quot;abc&quot;<br>   as an amount), is the error message easy to understand?<br>3. **Readable:** Could a beginner read this code and understand it?<br>4. **Rules followed:** Does the change follow every rule in `AGENTS.md`?<br>5. **Tests:** Is there a test for the new behaviour? Would the test<br>   fail if the code was wrong?<br><br>Reply with each question, PASS or FIX, and one line of reason.</pre><p>Today, you can try it yourself: open your coding agent in the repo and ask it to “review the last change using REVIEW.md.” In Part 5, we will turn this into a proper reviewer agent and talk about why a <em>separate</em> reviewer works better than asking the same agent to grade its own work.</p><h3>The fixed app</h3><p>With all four boxes in place, here is the fixed split_bill.py. It also gives a clear error if someone enters 0 people, which was one of the REVIEW.md questions:</p><pre>from money import format_cents<br><br><br>def split_bill(total_cents: int, people: int) -&gt; list[int]:<br>    &quot;&quot;&quot;Split total_cents equally between people.<br><br>    If the total does not divide evenly, the leftover cents are<br>    shared out one each, so every cent is paid and nobody pays<br>    more than 1 cent extra.<br>    &quot;&quot;&quot;<br>    if people &lt; 1:<br>        raise ValueError(f&quot;people must be at least 1, got {people}&quot;)<br>    base, leftover = divmod(total_cents, people)<br>    # The first `leftover` people pay one extra cent each<br>    return [base + 1 if i &lt; leftover else base for i in range(people)]</pre><p>For $100 between 7 friends, divmod(10000, 7) gives (1428, 4): each person pays 1428 cents, and 4 cents are left over. So four friends pay 1 extra cent each:</p><pre>Shares: [&#39;$14.29&#39;, &#39;$14.29&#39;, &#39;$14.29&#39;, &#39;$14.29&#39;, &#39;$14.28&#39;, &#39;$14.28&#39;, &#39;$14.28&#39;]<br>Total paid: $100.00</pre><p>And 0 people now gives a clear message:</p><pre>ValueError: people must be at least 1, got 0</pre><p>All tests:</p><pre>..............                                                           <br>[100%]<br>14 passed in 0.01s</pre><p>Every cent paid. Nobody pays more than 1 cent extra. Green.</p><h3>The steering loop: what you do when something slips through</h3><p>The four boxes are not a one-time setup. They grow.</p><p>Böckeler describes the human’s job as steering: when a problem keeps coming back, you improve the guides or sensors. I think of it as a loop:</p><figure><img alt="A loop of four steps with arrows between them: Agent makes a mistake, You spot it, Pick the right box, Add a guide or sensor, then back to the start. In the centre: Every loop makes the harness stronger." src="https://cdn-images-1.medium.com/max/1024/1*lb8aBHJPI1bTMREcOQINCQ.png" /><figcaption>Each time a mistake slips through, you add to the harness, and it gets stronger.</figcaption></figure><ol><li><strong>The agent makes a mistake.</strong> (The unfair split.)</li><li><strong>You spot it.</strong> (Friend 1 always pays more.)</li><li><strong>Pick the right box.</strong> Ask: could I stop this <em>before</em> (guide) or catch it <em>after</em> (sensor)? Can plain code check it (computational), or does it need judgement (inferential)?</li><li><strong>Add a guide or sensor.</strong> (The fairness rule in AGENTS.md and the fairness test.)</li></ol><p>This is the Part 1 mindset shift, made practical. “Don’t prompt harder, ask what is missing” now has a map to tell you <em>what kind</em> of thing is missing.</p><h3>Keep quality left: cheap checks first</h3><p>One more idea from Böckeler that I found really practical.</p><p>Not every check should run all the time. Tests take a second. An AI review might take a minute and cost money. So spread them out by speed and cost. She calls this <strong>keeping quality left</strong>, because on a timeline the left side is “earlier,” and problems caught earlier are cheaper to fix.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DYV4VnPL4giuKsq3pvwJlg.png" /></figure><ul><li><strong>Every change (seconds):</strong> tests, linters, type checks. Cheap, so run them all the time.</li><li><strong>Before merge (minutes):</strong> an AI review agent, bigger test suites.</li><li><strong>On a schedule (ongoing):</strong> checks that find slow drift, like dead code or outdated docs.</li></ul><p>We will build each of these columns in later parts of this series.</p><h3>Common mistakes</h3><p><strong>1. Thinking one green test means “done.”</strong> The sum test was green while the split was unfair. A test only checks what it checks. Ask: “What <em>else</em> could go wrong?”</p><p><strong>2. Only writing rules (guides), never checking them.</strong> “Splits must be fair” in AGENTS.md is a hope. The fairness test is a guarantee.</p><p><strong>3. Only adding tests (sensors), never teaching the rules.</strong> The agent will keep writing unfair splits and keep failing tests. That wastes time and money. Tell it the rule up front too.</p><p><strong>4. Using AI review for things plain code can check.</strong> “Do the shares add up?” doesn’t need an AI. A one-line test is faster, free, and gives the same answer every time. Save AI judgement for questions that need judgement.</p><p><strong>5. Error messages that only say “failed.”</strong> Write sensor messages that say what is wrong <em>and</em> how to fix it. The agent reads them.</p><h3>Recap</h3><ul><li>One test is not a harness. Part 1’s test passed while the split was unfair.</li><li><strong>Guides</strong> steer the agent before it acts. <strong>Sensors</strong> check its work after. You need both.</li><li>Each can be <strong>computational</strong> (plain code, fast, same every time) or <strong>inferential</strong> (AI judgement, slower, understands meaning). That gives four boxes.</li><li>When a mistake slips through, pick the right box and add to it. Run cheap checks early and costly ones later.</li></ul><h3>Try it yourself</h3><p>Draw the four boxes for one of your own projects. For each box, write what you already have. Then look at the empty boxes. That is your next harness task.</p><p>All the code is in the repo, tagged part-2: <a href="https://github.com/sai-sakalam/harness-engineering-from-scratch">harness-engineering-from-scratch</a>. Star it and watch it to follow along as the app grows.</p><p><strong>Tell me in the comments:</strong> which of the four boxes is empty in your project right now?</p><h3>What’s next</h3><p>In <strong>Part 3: AGENTS.md, a Map, Not a Manual</strong>, we zoom in on the inferential guide. Why does one giant instructions file fail? How do you write rules an agent actually follows?</p><p>Read all parts in order in the <a href="https://medium.com/@ssaigavaskar/list/harness-engineering-from-scratch-05934d98f463">series list</a>, and follow me so you don’t miss Part 3.</p><h3>Sources and further reading</h3><ul><li>Birgitta Böckeler, <em>Harness engineering for coding agent users</em>, martinfowler.com (April 2026): <a href="https://martinfowler.com/articles/harness-engineering.html">https://martinfowler.com/articles/harness-engineering.html</a></li><li>OpenAI, <em>Harness engineering: leveraging Codex in an agent-first world</em> (Feb 2026): <a href="https://openai.com/blog/harness-engineering">https://openai.com/blog/harness-engineering</a></li><li>Python docs, <em>decimal: Decimal fixed point and floating point arithmetic</em>: <a href="https://docs.python.org/3/library/decimal.html">https://docs.python.org/3/library/decimal.html</a></li><li>Part 1 of this series, <em>The Missing Cent</em>: <a href="https://medium.com/@ssaigavaskar/the-missing-cent-a-beginners-guide-to-harness-engineering-d003f92a706a">https://medium.com/@ssaigavaskar/the-missing-cent-a-beginners-guide-to-harness-engineering-d003f92a706a</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=37ae30bbfee8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Missing Cent: A Beginner’s Guide to Harness Engineering.]]></title>
            <link>https://medium.com/@ssaigavaskar/the-missing-cent-a-beginners-guide-to-harness-engineering-d003f92a706a?source=rss-d6d6a9d04fac------2</link>
            <guid isPermaLink="false">https://medium.com/p/d003f92a706a</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[harness-engineering]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[ai-coding]]></category>
            <category><![CDATA[ai-agents-in-action]]></category>
            <dc:creator><![CDATA[Sai Gavaskar Sakalam]]></dc:creator>
            <pubDate>Fri, 30 Oct 2026 07:39:35 GMT</pubDate>
            <atom:updated>2026-10-30T07:43:48.235Z</atom:updated>
            <content:encoded><![CDATA[<h3>AI agents can write code, but can you trust it? Part 1 of my Harness Engineering From Scratch series.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gO4YSj95uHig3cBbhTjtIA.png" /></figure><p><em>This is Part 1 of my series </em><strong><em>Harness Engineering From Scratch</em></strong><em>. I am learning this topic from zero and sharing everything I learn, one idea per part.</em></p><h3>The missing cent</h3><p>Three friends go out for dinner. The bill is $100. They want to split it equally.</p><p>Easy, right? Here is a small Python function that looks perfect:</p><pre>def split_bill(total, people):<br>    share = round(total / people, 2)<br>    return [share] * people<br><br>shares = split_bill(100, 3)<br>print(&quot;Shares:&quot;, shares)<br>print(&quot;Total paid:&quot;, sum(shares))</pre><p>Output:</p><pre>Shares: [33.33, 33.33, 33.33]<br>Total paid: 99.99</pre><p>Look at the last line. The friends paid <strong>$99.99</strong>, not $100.</p><p>One cent is gone.</p><p>Nobody notices it at the table. But the restaurant will. And if this code runs a million times in a real app, those missing cents become real money.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OS6SmeH8gRusdel7PPD4XA.png" /><figcaption>$100 split three ways gives $33.33 each, which adds up to only $99.99.</figcaption></figure><p>Now imagine an AI agent wrote this code for you. It looks clean. It runs. No error. You would probably accept it.</p><p>This is exactly the problem that <strong>harness engineering</strong> tries to solve.</p><h3>Why I started learning this</h3><p>Lately I keep seeing the words “harness engineering” everywhere. In engineering blogs, in podcasts, in posts from AI companies.</p><p>At first I thought it was just a fancy new name for “writing better prompts.” It is not.</p><p>So I decided to study it properly, from scratch, and write down what I learn. This series is my notes. If you are a beginner, a student, or a data person like me, we will learn it together.</p><h3>First, a few words you need</h3><p>Before we go further, let me explain some words in plain English.</p><ul><li><strong>Model:</strong> the AI brain. For example, the large language model behind tools like ChatGPT or Claude. It reads text and writes text.</li><li><strong>AI agent:</strong> a model that can also <em>do things</em>, like read files, run code, and fix its own mistakes in a loop. Claude Code and OpenAI Codex are examples of coding agents.</li><li><strong>Harness:</strong> everything around the model that helps it do good work. Rules, tests, checks, docs, reviewers.</li><li><strong>Test:</strong> a small piece of code that checks if other code works correctly.</li></ul><p>That’s all we need for today.</p><h3>The idea, explained with a kitchen</h3><p>Imagine a busy restaurant hires a new cook.</p><p>He is very talented. He can cook almost anything. But he is new. He does not know this kitchen’s rules. Does this restaurant use salted butter or unsalted? Where are the spices? How spicy is “medium” here?</p><p>On his first day, he makes a dish that is too salty.</p><p>What should the owner do?</p><p><strong>Option 1:</strong> Shout at him. “Use less salt!” Next week, a different dish is too salty again.</p><p><strong>Option 2:</strong> Build a better kitchen around him.</p><ul><li>A <strong>recipe binder</strong> with the house rules (“medium spicy = 1 chilli”).</li><li>A <strong>taster</strong> who checks every dish before it leaves the kitchen.</li><li><strong>Labelled shelves</strong>, so he always grabs the right thing.</li><li>A <strong>nightly cleanup</strong>, so the kitchen does not get messy over time.</li></ul><p>Option 2 does not make the cook smarter. It makes his <em>work reliable</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bhNNAG1HspXbP6eInsLHcA.png" /><figcaption>A talented cook works best in a kitchen with clear rules, a taster, labelled shelves and regular cleanup.</figcaption></figure><p>That kitchen setup is the <strong>harness</strong>. Building it is <strong>harness engineering</strong>.</p><h3>The real version: Agent = Model + Harness</h3><p>Now let’s bring this back to code.</p><p>The AI model is the talented cook. It is very capable. But it does not know your project’s rules, and it does not check its own work unless something makes it.</p><p>People who work with AI agents use a simple shorthand for this:</p><p><strong>Agent = Model + Harness</strong></p><p>You usually cannot change the model. You cannot retrain Claude or GPT. But you <em>can</em> change everything around it:</p><ul><li>Instruction files that tell the agent your rules (often called <strong>AGENTS.md</strong>)</li><li><strong>Tests</strong> that check if the code really works</li><li><strong>Linters</strong>, tools that check code style and catch common mistakes automatically</li><li><strong>Review agents</strong>, a second AI that checks the first AI’s work</li><li><strong>Docs</strong> that explain how your project is built</li><li><strong>Cleanup jobs</strong> that find and fix messy code over time</li></ul><figure><img alt="A small purple circle labelled “Model, the AI brain” sits inside a larger blue circle labelled “Harness, everything around the model”. Six labels sit in the blue ring: AGENTS.md, Tests, Linters, Review agent, Docs, Cleanup jobs. The title reads “Agent = Model + Harness”." src="https://cdn-images-1.medium.com/max/1024/1*zm7R20AuQcJez8uzpA9yuw.png" /><figcaption>The model is the brain in the middle. The harness is everything around it that makes its work reliable.</figcaption></figure><p><strong>Harness engineering</strong> is the skill of designing that environment, so the agent does good work again and again, not just once by luck.</p><h3>Where did this term come from?</h3><p>The idea is old, but the name is new. It became popular in early 2026.</p><p><strong>Mitchell Hashimoto</strong> (creator of Terraform and Ghostty) wrote a blog post in February 2026 called “My AI Adoption Journey.” One of his steps was literally called “Engineer the Harness.” He described it as two things: AGENTS.md files, and real tools like scripts that help the agent check its own work.</p><p>A few days later, <strong>OpenAI</strong> published a post called “Harness engineering.” Their team built a real product over five months where humans wrote <strong>zero lines of code by hand</strong>. Agents wrote everything: about a million lines, across roughly 1,500 merged pull requests, with a small team of engineers steering. They wrote that early progress was slow, not because the agent was weak, but because its environment was not set up well. Designing that environment became the team’s main job.</p><p>Then <strong>Birgitta Böckeler</strong> at Thoughtworks wrote a clear mental model for it on martinfowler.com. She splits a harness into two kinds of controls:</p><ul><li><strong>Guides</strong> steer the agent <em>before</em> it acts (like the recipe binder).</li><li><strong>Sensors</strong> check the work <em>after</em> it acts (like the taster).</li></ul><p>We will go deep into guides and sensors in Part 2. For today, just remember: <strong>guide before, sensor after.</strong></p><h3>Prompt vs context vs harness engineering</h3><p>You may have heard of “prompt engineering” and “context engineering.” Here is how they fit together. Think of them as three boxes, one inside the other.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wWtH_aHazxM2zPVk7WrApA.png" /><figcaption>Prompt engineering lives inside context engineering, and both live inside harness engineering.</figcaption></figure><ul><li><strong>Prompt engineering</strong> is <em>what you ask</em>, right now. “Split this bill between 3 friends.”</li><li><strong>Context engineering</strong> is <em>what the agent knows</em> while working. Your files, docs, and past decisions.</li><li><strong>Harness engineering</strong> is <em>the whole environment</em>. The rules, tests, checks, reviewers and cleanup that make the work reliable every single time.</li></ul><p>A great prompt helps once. A great harness helps every time.</p><h3>The mindset shift</h3><p>This was the biggest “aha” for me while reading.</p><p>When an AI agent makes a mistake, most of us do this: we type the prompt again, maybe louder. “Please be careful with money this time!” It works today. Next week, a different chat, same mistake.</p><p>The OpenAI team describes a different habit. When the agent failed, they did not ask it to “try harder.” They asked: <strong>what capability is missing?</strong> Then they added that missing piece to the project itself, as a document, a tool, or a check, so the same mistake would be caught every time after that.</p><figure><img alt="Two panels. Left panel, “Old way”: Agent makes a mistake, then Prompt it again louder, then Same mistake next week, with an arrow looping back to the start. Right panel, “Harness way”: Agent makes a mistake, then What is missing?, then Add a rule or a check, then Never fails this way again." src="https://cdn-images-1.medium.com/max/1024/1*nWvyPJB4CzYOCzGaTcxwqQ.png" /><figcaption>The old way repeats the same mistake. The harness way fixes it for good.</figcaption></figure><p>That is the heart of harness engineering. <strong>Every mistake becomes a permanent improvement to the environment.</strong></p><h3>Real example: our first guide and first sensor</h3><p>Let’s fix the missing cent the harness way. We will add two things:</p><ol><li>A <strong>sensor</strong>: a test that catches the bug.</li><li>A <strong>guide</strong>: a rule that steers the agent away from the bug.</li></ol><h3>Step 1: The sensor (a test)</h3><p>What is the one thing that must always be true when you split a bill?</p><p><strong>Everyone’s shares must add up to the total.</strong> Not almost. Exactly.</p><p>Let’s write that as a test using <strong>pytest</strong>, a popular Python testing tool:</p><pre># test_split_bill.py<br>from split_bill import split_bill<br><br>def test_shares_add_up_to_total():<br>    shares = split_bill(100, 3)<br>    assert sum(shares) == 100</pre><p>assert means &quot;this must be true, or fail loudly.&quot;</p><p>Run it:</p><pre>python -m pytest -q test_split_bill.py</pre><p>Output:</p><pre>F                                                                        [100%]<br>=================================== FAILURES ===================================<br>_________________________ test_shares_add_up_to_total __________________________<br><br>    def test_shares_add_up_to_total():<br>        shares = split_bill(100, 3)<br>&gt;       assert sum(shares) == 100<br>E       assert 99.99 == 100<br>E        +  where 99.99 = sum([33.33, 33.33, 33.33])<br><br>test_split_bill.py:5: AssertionError<br>=========================== short test summary info ============================<br>FAILED test_split_bill.py::test_shares_add_up_to_total - assert 99.99 == 100<br>1 failed in 0.02s</pre><p>The test caught it: assert 99.99 == 100.</p><p>And here is the important part. A coding agent like Claude Code or Codex can run this test itself, read this error, and understand exactly what went wrong. <strong>The test is not only for you. It is feedback for the agent.</strong></p><h3>Step 2: The guide (a rule in AGENTS.md)</h3><p>Why did the bug happen? Two reasons:</p><ol><li>We rounded each share separately, so the leftover cent disappeared.</li><li>We used decimal numbers (called <strong>floats</strong> in Python) for money. Floats are not exact. Try this:</li></ol><pre>print(0.1 + 0.2)</pre><p>Output:</p><pre>0.30000000000000004</pre><p>Not exactly 0.3! For money, that tiny error can cause big trouble.</p><p>The common fix used in real payment systems is simple: <strong>store money as whole cents.</strong> $100.00 becomes 10000. Whole numbers are always exact.</p><p>So we write that rule down in a file called <strong>AGENTS.md</strong>. This is a plain text file in your project that coding agents read to learn your rules. Think of it as the recipe binder.</p><pre># AGENTS.md<br><br><br>## Money rules<br>- Always store money as whole cents (int), never float.<br>  Example: $100.00 is 10000.<br>- When splitting, every cent must be paid by someone.<br>  The shares must always add up to the exact total.<br>- Run `python -m pytest` after every change. All tests must pass.</pre><p>Short. Clear. Easy to check.</p><h3>Step 3: The fix</h3><p>Now the code follows the rule. We work in cents, and if there is a leftover cent, the first person pays it:</p><p>python</p><pre># split_bill.py<br>def split_bill(total_cents, people):<br>    base, leftover = divmod(total_cents, people)<br>    # The first `leftover` people pay one extra cent<br>    return [base + 1 if i &lt; leftover else base for i in range(people)]<br><br>shares = split_bill(10000, 3)  # $100.00 in cents<br>print(&quot;Shares (cents):&quot;, shares)<br>print(&quot;Total paid (cents):&quot;, sum(shares))</pre><p>divmod(10000, 3) gives two numbers at once: the base share and the leftover.</p><pre>print(divmod(10000, 3))</pre><p>Output:</p><pre>(3333, 1)</pre><p>So each friend pays 3333 cents, and 1 cent is left over. The first friend pays it.</p><p>Output of the fixed function:</p><pre>Shares (cents): [3334, 3333, 3333]<br>Total paid (cents): 10000</pre><p>That is $33.34 + $33.33 + $33.33 = <strong>$100.00</strong>. Every cent paid.</p><p>We update the test to use cents too, and run it again:</p><pre>def test_shares_add_up_to_total():<br>    shares = split_bill(10000, 3)<br>    assert sum(shares) == 10000</pre><pre>.                                                                        <br>[100%]<br>1 passed in 0.01sGreen. Every cent is paid.</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jj11Xx2-dszwyapfbI7TXw.png" /><figcaption>The guide steers the agent before it writes code. The sensor checks the result after.</figcaption></figure><ul><li>The <strong>guide</strong> (AGENTS.md) makes it <em>more likely</em> the agent writes correct code the first time.</li><li>The <strong>sensor</strong> (the test) <em>catches</em> the bug if the agent gets it wrong anyway.</li><li>If the test fails, the error message tells the agent what to fix, and it tries again.</li></ul><p>Guides alone are not enough, because agents do not always follow written rules. Sensors alone are not enough either, because fixing mistakes after the fact wastes time. <strong>Together, they make a harness.</strong></p><p>And the best part: this test will catch this bug <em>forever</em>. For any agent. In any chat. Even six months from now when you have forgotten all about the missing cent.</p><h3>Common mistakes when starting out</h3><p><strong>1. Thinking harness engineering is just a longer prompt.</strong> A prompt lives in one chat and disappears. A harness lives in your project and works every time.</p><p><strong>2. Writing one giant instructions file.</strong> OpenAI tried this and found it failed. When everything is “important,” the agent cannot tell what really matters. Keep AGENTS.md short, like a map, not a 1,000-page manual. (Part 3 is all about this.)</p><p><strong>3. Writing rules but never checking them.</strong> “Never use float for money” in a doc is a hope. A test that fails when shares don’t add up is a guarantee. If a rule matters, back it with a check.</p><p><strong>4. Fixing the bug once and moving on.</strong> If you only fix the code, the same mistake can come back next week. Fix the code <em>and</em> add a guide or sensor so it cannot come back.</p><h3>Recap</h3><ul><li><strong>Agent = Model + Harness.</strong> You can’t change the model, but you can change everything around it.</li><li><strong>Harness engineering</strong> is designing that environment so AI agents do reliable work every time.</li><li><strong>Guides</strong> steer before the agent acts. <strong>Sensors</strong> check after.</li><li>When an agent fails, don’t prompt harder. Ask <strong>what is missing</strong> and add it to the project.</li></ul><h3>Try it yourself</h3><p>Pick one mistake your AI agent keeps making in your own project. Then:</p><ol><li>Write <strong>one rule</strong> for it in an AGENTS.md file.</li><li>Write <strong>one test</strong> or check that fails when the mistake happens.</li></ol><p>That’s it. You have built your first harness.</p><p><strong>All the code from this series lives in one GitHub repo:</strong> <a href="https://github.com/sai-sakalam/harness-engineering-from-scratch">harness-engineering-from-scratch</a>. It grows with every part, and each part is tagged so you can see the code exactly as it was at that step. Star it and watch it to follow along.</p><p><strong>Tell me in the comments:</strong> what is the one mistake your AI coding agent keeps repeating? I may use the best ones as examples later in this series.</p><h3>What’s next</h3><p>In <strong>Part 2: Guides and Sensors</strong>, we go deeper into the mental model. You will learn the two types of sensors (computational and inferential), and we will map out every guide and sensor we will add to our Split the Bill app across this series.</p><p>Follow me so you don’t miss it, and save the series list to read all parts in order.</p><h3>Sources and further reading</h3><ul><li>Mitchell Hashimoto, <em>My AI Adoption Journey</em> (Feb 2026): <a href="https://mitchellh.com/writing/my-ai-adoption-journey">https://mitchellh.com/writing/my-ai-adoption-journey</a></li><li>OpenAI, <em>Harness engineering: leveraging Codex in an agent-first world</em> (Feb 2026): <a href="https://openai.com/blog/harness-engineering">https://openai.com/blog/harness-engineering</a></li><li>Birgitta Böckeler, <em>Harness engineering for coding agent users</em>, martinfowler.com (2026): <a href="https://martinfowler.com/articles/harness-engineering.html">https://martinfowler.com/articles/harness-engineering.html</a></li><li>Anthropic, <em>Effective harnesses for long-running agents</em>: <a href="https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents">https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d003f92a706a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Breaks When You Upgrade to pandas 3]]></title>
            <link>https://medium.com/@ssaigavaskar/what-breaks-when-you-upgrade-to-pandas-3-f0f31f1a5be1?source=rss-d6d6a9d04fac------2</link>
            <guid isPermaLink="false">https://medium.com/p/f0f31f1a5be1</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[pandas]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Sai Gavaskar Sakalam]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 05:18:56 GMT</pubDate>
            <atom:updated>2026-10-15T05:18:56.049Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The four changes that broke my old notebooks, and the one-line fix for each</em></p><p>I am a data engineer, and I use pandas a lot in my own projects and learning outside work. When a big library releases a new major version, I like to know what changed before I upgrade.</p><p><strong>pandas 3.0</strong> came out on January 21, 2026. It removed many old shortcuts that pandas 2 had been warning about for years. If your code still uses them, it stops working the day you upgrade.</p><p>I wanted to know exactly what breaks <em>before</em> it breaks for me. So I took common pandas 2 code, the kind you see in tutorials, courses and notebooks everywhere, and ran it on pandas 3. This was one of the first things I got:</p><pre>TypeError: NDFrame.fillna() got an unexpected keyword argument &#39;method&#39;</pre><p>The code did not change. Only pandas changed.</p><p>In this article I will show you the four changes you are most likely to hit first. For each one, you get the real error message, a simple everyday example, and the fix.</p><figure><img alt="A road from pandas 2.2 or older, to pandas 2.3 (fix every warning), to pandas 3.0. A dashed red arrow that skips 2.3 says “straight to errors”. Below, four boxes list what changes in 3.0: str type, Copy-on-Write, removed shortcuts, microsecond dates." src="https://cdn-images-1.medium.com/max/1024/1*voH8gzDw0p9WsVizqt6yFg.png" /><figcaption><em>The safe road to pandas 3 goes through pandas 2.3 first.</em></figcaption></figure><h3>Try it now (30 seconds)</h3><p>First, check which pandas you have. Open a terminal and run:</p><pre>python -c &quot;import pandas, sys; print(&#39;pandas&#39;, pandas.__version__); print(&#39;Python&#39;, sys.version.split()[0])&quot;</pre><p>My output:</p><pre>pandas 3.0.5<br>Python 3.13.16</pre><p>How to read it:</p><ul><li><strong>pandas 2.x</strong> — you are on the old rules. This article tells you what will break when you move.</li><li><strong>pandas 3.x</strong> — you are on the new rules. If old code fails, the fix is probably below.</li><li><strong>Python older than 3.11</strong> — pandas 3 needs Python 3.11 or newer, so pip quietly gives you the last 2.x version instead.</li></ul><p>All the code in this article was run on pandas 3.0.5. The newest release right now is 3.0.6 (September 17, 2026), and it has the same rules.</p><h3>The idea: the school changed its rule book</h3><p>Think of a school. Over the summer, the school prints a new rule book.</p><p>Most rules are the same. But a few old shortcuts are now not allowed. The teachers were not hiding this. All last year, they kept saying: “Next year, this shortcut will not work.” Many of us heard it and kept using the shortcut anyway.</p><p>That is exactly what happened with pandas.</p><p>In pandas, that teacher’s warning is called a <strong>deprecation warning</strong>. “Deprecated” simply means: <em>this still works today, but it will be removed later, so please stop using it.</em> In pandas 2.x, you saw these as yellow FutureWarning or DeprecationWarning messages. Most of us scrolled past them.</p><p>pandas 3.0 is the new rule book. The removed shortcuts now give a real error, not a warning.</p><p>The pandas team’s own advice is simple:</p><ol><li>First upgrade to <strong>pandas 2.3</strong>.</li><li>Run your code and fix every warning you see.</li><li>Then upgrade to <strong>pandas 3.0</strong>.</li></ol><p>If you jump straight from an old version to 3.0, you skip the warnings and go straight to the errors.</p><p>Now let’s see the four changes.</p><h3>1. Text columns now say “str”, not “object”</h3><p>Think of a <strong>junk drawer</strong> in your kitchen. You can throw anything in it: keys, a spoon, a battery, a pen.</p><p>Now think of a <strong>pencil box</strong>. It holds only pencils. If you try to put a spoon in it, it does not fit.</p><p>Before pandas 3, every text column was a junk drawer. Its type was object, which means &quot;any Python thing can go here&quot;. From pandas 3, text columns get their own pencil box: a new type called str.</p><pre>import pandas as pd</pre><pre>s = pd.Series([&quot;apple&quot;, &quot;banana&quot;])<br>print(s)<br>print(s.dtype == object)</pre><p>Output on pandas 3:</p><pre>0     apple<br>1    banana<br>dtype: str<br>False</pre><p>In pandas 2, the last line of the Series said dtype: object, and the check said True.</p><p><strong>What breaks:</strong></p><ul><li>Code that checks if df[&quot;name&quot;].dtype == object: now quietly goes the other way.</li><li>Putting a number into a text column now fails:</li></ul><pre>s[0] = 5</pre><pre>TypeError: Invalid value &#39;5&#39; for dtype &#39;str&#39;. Value should be a string or missing value, got &#39;int&#39; instead.</pre><p><strong>The fix:</strong> check for text with pd.api.types.is_string_dtype(s) instead of comparing to object. And if you really want to put a number in, convert it first: s[0] = &quot;5&quot;.</p><p>Good news: the new str type is faster and uses less memory when PyArrow is installed. pandas uses PyArrow under the hood if it is there.</p><figure><img alt="A messy drawer labelled object with mixed items, next to a neat pencil box labelled str that holds only strings." src="https://cdn-images-1.medium.com/max/1024/1*EbrEqHmxzBiEt0054v81Lg.png" /><figcaption><em>In pandas 3, a text column holds only text.</em></figcaption></figure><h3>2. “ChainedAssignmentError” and nothing changes</h3><p>This one is sneaky, because your code does not crash. It just does nothing.</p><p>Imagine your friend gives you a <strong>photocopy</strong> of her homework. You write a correction on the photocopy. Does her original page change? No. Only the photocopy changes.</p><p>pandas 3 follows the same rule. It is called <strong>Copy-on-Write</strong>. Every time you filter or select something from a DataFrame, you get something that behaves like a photocopy. Writing on it never changes the original.</p><p>Now, a common old pattern is <strong>chained assignment</strong>. That means picking rows, then picking a column, then setting a value, all in one chain with two pairs of square brackets:</p><pre>df = pd.DataFrame({&quot;name&quot;: [&quot;Asha&quot;, &quot;Ravi&quot;, &quot;Meena&quot;],<br>                   &quot;marks&quot;: [35, 72, 90]})</pre><pre># Give everyone below 40 a grace mark of 40<br>df[df[&quot;marks&quot;] &lt; 40][&quot;marks&quot;] = 40<br>print(df)</pre><p>Output on pandas 3:</p><pre>ChainedAssignmentError: A value is being set on a copy of a DataFrame or Series through chained assignment.<br>Such chained assignment never works to update the original DataFrame or Series ...</pre><pre>    name  marks<br>0   Asha     35<br>1   Ravi     72<br>2  Meena     90</pre><p>Asha still has 35. The first part df[df[&quot;marks&quot;] &lt; 40] made a photocopy, and we wrote 40 on the photocopy.</p><p><strong>The fix:</strong> do it in one step with .loc, so you write on the original page:</p><pre>df.loc[df[&quot;marks&quot;] &lt; 40, &quot;marks&quot;] = 40<br>print(df)</pre><pre>name  marks<br>0   Asha     40<br>1   Ravi     72<br>2  Meena     90</pre><p>The ChainedAssignmentError above is printed as a warning, so your program keeps running with the wrong result. Read your warnings!</p><p>There is good news here too. The old SettingWithCopyWarning is gone. You also do not need those extra .copy() calls that we used to add &quot;just to be safe&quot;.</p><figure><img alt="Two paths from one DataFrame. A chained write lands on a copy and the original stays the same. A .loc write updates the original." src="https://cdn-images-1.medium.com/max/1024/1*KBFpcsfq9efHw2V06oKDdw.png" /><figcaption><em>Writing on a filtered copy never changes the original. Use .loc to change it.</em></figcaption></figure><h3>3. “has no attribute ‘applymap’” and other removed shortcuts</h3><p>Imagine your bus route is closed. The bus still goes to your school, but it now takes a new road. You just need to know the new route number.</p><p>Many old functions and arguments were closed in pandas 3. Here are the four I hit, with the real errors and the new routes.</p><p><strong>applymap → map</strong></p><pre>prices = pd.DataFrame({&quot;tea&quot;: [1.5, 2.25], &quot;coffee&quot;: [3.0, 4.75]})<br>prices.applymap(lambda x: f&quot;${x:.2f}&quot;)</pre><pre>AttributeError: &#39;DataFrame&#39; object has no attribute &#39;applymap&#39;</pre><pre>print(prices.map(lambda x: f&quot;${x:.2f}&quot;))</pre><pre>tea coffee<br>0  $1.50  $3.00<br>1  $2.25  $4.75</pre><p><strong>fillna(method=”ffill”) → ffill()</strong></p><p>“Forward fill” means: copy the last known value down into the empty cells below it.</p><pre>temps = pd.DataFrame({&quot;temp&quot;: [30.0, None, None, 33.0]})<br>temps.fillna(method=&quot;ffill&quot;)</pre><pre>TypeError: NDFrame.fillna() got an unexpected keyword argument &#39;method&#39;</pre><pre>print(temps.ffill())</pre><pre>temp<br>0  30.0<br>1  30.0<br>2  30.0<br>3  33.0</pre><p>Same idea for method=&quot;bfill&quot;: use .bfill().</p><p><strong>freq=”M” → freq=”ME”</strong></p><pre>pd.date_range(&quot;2026-01-31&quot;, periods=3, freq=&quot;M&quot;)</pre><pre>ValueError: Invalid frequency: M. Failed to parse with error message: ValueError(&quot;&#39;M&#39; is no longer supported for offsets. Please use &#39;ME&#39; instead.&quot;)</pre><pre>print(pd.date_range(&quot;2026-01-31&quot;, periods=3, freq=&quot;ME&quot;))</pre><pre>DatetimeIndex([&#39;2026-01-31&#39;, &#39;2026-02-28&#39;, &#39;2026-03-31&#39;], dtype=&#39;datetime64[us]&#39;, freq=&#39;ME&#39;)</pre><p>“ME” means <strong>M</strong>onth <strong>E</strong>nd. The same change applies to quarter and year: Q → QE, Y → YE.</p><p><strong>swapaxes → transpose</strong></p><pre>prices.swapaxes(0, 1)</pre><pre>AttributeError: &#39;DataFrame&#39; object has no attribute &#39;swapaxes&#39;</pre><pre>print(prices.T)</pre><pre>0     1<br>tea     1.5  2.25<br>coffee  3.0  4.75</pre><p>.T is the short name for .transpose(). It flips rows and columns.</p><figure><img alt="Four arrows: applymap to map, fillna method to ffill, M to ME, and swapaxes to T." src="https://cdn-images-1.medium.com/max/1024/1*I2yKtuusRrDvBrdJp5mJ5Q.png" /><figcaption><em>Four old shortcuts and what to use instead.</em></figcaption></figure><h3>4. Dates use microseconds now, and your integers shrink 1000 times</h3><p>Think of two rulers. One is marked in tiny nanosecond steps. The other is marked in microsecond steps, which are 1000 times bigger. If you measure the same pencil, you get the same length. But if you count the marks, one ruler says 1000 times more.</p><p>(A <strong>nanosecond</strong> is one billionth of a second. A <strong>microsecond</strong> is one millionth of a second.)</p><p>Before pandas 3, every date was measured with the nanosecond ruler. Now, when pandas reads date text, it uses the microsecond ruler by default.</p><pre>t = pd.to_datetime(pd.Series([&quot;2026-10-14 09:30&quot;]))<br>print(t)</pre><pre>0   2026-10-14 09:30:00<br>dtype: datetime64[us]</pre><p>In pandas 2 this said datetime64[ns].</p><p>For most work, you will never notice. The date looks the same. The trap is when you turn dates into numbers:</p><pre>print(t.astype(&quot;int64&quot;)[0])</pre><pre>1791970200000000</pre><p>That is microseconds. Your old code may expect nanoseconds, which is 1000 times bigger. If you store these numbers or compare them with old data, you get wrong answers with no error.</p><p><strong>The fix:</strong> say which ruler you want before converting:</p><pre>print(t.dt.as_unit(&quot;ns&quot;).astype(&quot;int64&quot;)[0])</pre><pre>1791970200000000000</pre><figure><img alt="Two rulers measuring one timestamp, one in nanoseconds and one in microseconds, giving numbers 1000 times apart." src="https://cdn-images-1.medium.com/max/1024/1*QltpiRSsEJPs3Km4SDzGnA.png" /><figcaption><em>Same date, different unit. The integers differ by 1000 times.</em></figcaption></figure><h3>A real run: fixing a small sales report</h3><p>Here is a small sales report script, the kind many of us have written. It makes 90 days of sales, has one empty day, fills the gap, and adds up each month.</p><pre># report.py (old version)<br>import pandas as pd</pre><pre>sales = pd.DataFrame({<br>    &quot;day&quot;: pd.date_range(&quot;2026-01-01&quot;, periods=90, freq=&quot;D&quot;),<br>    &quot;amount&quot;: [100.0] * 90,<br>})<br>sales.loc[5, &quot;amount&quot;] = None</pre><pre>sales = sales.fillna(method=&quot;ffill&quot;)<br>monthly = sales.resample(&quot;M&quot;, on=&quot;day&quot;)[&quot;amount&quot;].sum()<br>print(monthly)</pre><p>First run on pandas 3:</p><pre>sales = sales.fillna(method=&quot;ffill&quot;)<br>TypeError: NDFrame.fillna() got an unexpected keyword argument &#39;method&#39;</pre><p>I changed it to sales.ffill() and ran again. A new error:</p><pre>ValueError: Invalid frequency: M. Failed to parse with error message: ValueError(&quot;&#39;M&#39; is no longer supported for offsets. Please use &#39;ME&#39; instead.&quot;)</pre><p>This is normal. Python stops at the <strong>first</strong> error, so you fix one, then the next one appears. Do not panic when a second error shows up. It means you made progress.</p><p>After changing &quot;M&quot; to &quot;ME&quot;, here is the fixed version:</p><pre># report.py (pandas 3 version)<br>sales = sales.ffill()<br>monthly = sales.resample(&quot;ME&quot;, on=&quot;day&quot;)[&quot;amount&quot;].sum()<br>print(monthly)</pre><pre>day<br>2026-01-31    3100.0<br>2026-02-28    2800.0<br>2026-03-31    3100.0<br>Freq: ME, Name: amount, dtype: float64</pre><p>Two small changes, and the report works again. January has 31 days × 100 = 3100, and the empty day was filled from the day before.</p><h3>Tips and common mistakes</h3><ul><li><strong>Don’t jump straight to 3.0.</strong> Go to pandas 2.3 first and fix the warnings. The warnings tell you exactly which line will break.</li><li><strong>Read the yellow warnings.</strong> ChainedAssignmentError is only a warning, but your result is wrong.</li><li><strong>Pin your pandas version.</strong> Write pandas==2.3.3 or pandas&gt;=3,&lt;4 in requirements.txt. Then a new server or a teammate&#39;s laptop will not upgrade you by surprise.</li><li><strong>Check your Python version.</strong> pandas 3 needs Python 3.11 or newer.</li><li><strong>Missing </strong><strong>pytz?</strong> pandas 3 no longer installs it for you. If your code imports it, run pip install &quot;pandas[timezone]&quot; or install pytz yourself.</li><li><strong>Delete the extra </strong><strong>.copy() calls.</strong> You added them to silence old warnings. With Copy-on-Write, they are not needed.</li><li><strong>Upgrade in a new virtual environment first.</strong> Test there, then move your real project. (Not sure what a virtual environment is? My last article explains it.)</li></ul><h3>Recap</h3><ul><li>Text columns are now str, not object. Check them with is_string_dtype.</li><li>Filtered data behaves like a photocopy. Use one .loc[...] to change the original.</li><li>Old shortcuts are gone: applymap → map, fillna(method=...) → ffill()/bfill(), &quot;M&quot; → &quot;ME&quot;, swapaxes → .T.</li><li>Dates use microseconds now. Use .dt.as_unit(&quot;ns&quot;) before turning them into integers.</li></ul><h3>Try it and tell me what broke</h3><p>Pick one old notebook today. Make a new virtual environment, install pandas 3, and press Run. Then come back and tell me in the comments: <strong>which error did you hit first?</strong> If it is not in this article, I will add it to Part 2.</p><p>If this helped you, please clap and follow. I write about whatever I am learning or building: Python tools, Databricks, PySpark and data engineering.</p><p><strong>Coming next, Part 2:</strong> time zones (pandas now uses Python’s own zoneinfo instead of pytz), the Day offset and daylight saving time, and how to find these problems in your whole project automatically, before you run anything.</p><p><strong>Links</strong></p><ul><li><a href="https://pandas.pydata.org/docs/whatsnew/v3.0.0.html">What’s new in pandas 3.0.0 (official release notes)</a></li><li><a href="https://pandas.pydata.org/docs/user_guide/migration-3-strings.html">Migration guide for the new string type</a></li><li><a href="https://pandas.pydata.org/docs/user_guide/copy_on_write.html">Copy-on-Write user guide</a></li><li><a href="https://medium.com/@ssaigavaskar/fix-5-python-setup-errors-with-one-command-d6ffb30dd5ec">My previous article: Fix 5 Python Setup Errors With One Command</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0f31f1a5be1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fix 5 Python Setup Errors With One Command]]></title>
            <link>https://python.plainenglish.io/fix-5-python-setup-errors-with-one-command-d6ffb30dd5ec?source=rss-d6d6a9d04fac------2</link>
            <guid isPermaLink="false">https://medium.com/p/d6ffb30dd5ec</guid>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[pip]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[python-programming]]></category>
            <dc:creator><![CDATA[Sai Gavaskar Sakalam]]></dc:creator>
            <pubDate>Mon, 12 Oct 2026 14:11:40 GMT</pubDate>
            <atom:updated>2026-10-12T14:33:30.076Z</atom:updated>
            <content:encoded><![CDATA[<h3>pyfirstaid is a free tool that checks your Python environment and gives you a copy-paste fix for every problem.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mRPKoAteg5D5dkGcXgqR_A.png" /></figure><p>You type pip install requests. It says “Successfully installed”. You feel good.</p><p>Then you run your script:</p><pre>ModuleNotFoundError: No module named &#39;requests&#39;</pre><p>But you <em>just</em> installed it.</p><p>When I first hit this, I lost a whole evening. I reinstalled the package. I reinstalled Python. I opened twelve Stack Overflow tabs. Each answer fixed a different problem, and none of them told me which problem <em>I</em> had.</p><p>Here is the thing I learned later. Most of the time, your code is fine. Your <strong>environment</strong> is broken.</p><p>So I built a small tool that checks the environment for you, tells you what is wrong in plain English, and gives you the exact command to fix it. It is called <strong>pyfirstaid</strong>, and it is free and open source.</p><h3>Try it now (30 seconds)</h3><pre>pip install pyfirstaid<br>python -m pyfirstaid</pre><p>That is it. You get a list of checks. Each line starts with one of three symbols:</p><ul><li><strong>✔</strong> means this part is fine.</li><li><strong>!</strong> means a warning. Take a look.</li><li><strong>✘</strong> means a problem. Here is the fix.</li></ul><p>If you only had 30 seconds, you are done. If you want to understand <em>why</em> these errors happen, keep reading.</p><h3>The idea: a check-up, not surgery</h3><p>Think about a visit to the doctor for a check-up. The doctor checks your heart, your blood pressure and your eyes. Then the doctor tells you what is wrong and which medicine to take. The doctor does not start an operation without asking you.</p><p>pyfirstaid works the same way. It runs <strong>12 checks</strong> on your Python setup and prints a fix for every problem it finds. It only <em>diagnoses</em>. It never changes anything on your machine. You decide what to run.</p><p>A few words we will use, explained once:</p><ul><li><strong>Environment:</strong> everything your Python uses when it runs. Which Python program, which installed packages, and which settings.</li><li><strong>Virtual environment (venv):</strong> a private box of packages for one project, so projects do not mix their packages.</li><li><strong>site-packages:</strong> the folder where pip puts the packages it installs. Every Python has its own.</li><li><strong>PATH:</strong> a list of folders your computer searches, in order, when you type a command like python3.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1SliB57DrQXoxfymcBFHhg.png" /><figcaption>One command checks your whole Python setup and gives a fix for each problem.</figcaption></figure><p>Now let us look at the five errors I see most, one by one.</p><h3>1. “ModuleNotFoundError” right after pip install</h3><p>Imagine you have two kitchens in your house. You put the groceries in kitchen A. Then you go to kitchen B to cook. Of course the vegetables are not there.</p><p>This is exactly what happens when pip and python belong to <strong>different Pythons</strong>. Your computer can have many Pythons: the system one, one from Homebrew or python.org, one inside your project’s venv. The pip command might belong to one of them, while the python command runs another. The package goes into the first one’s site-packages. Your script runs with the second one, and it cannot see the package.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uJ2V7hWYR57k_0Z_mH87Zw.png" /><figcaption>When pip and python point to different places, your package lands in the wrong one.</figcaption></figure><p>Check it:</p><pre>python -m pyfirstaid --only pip-mismatch,venv</pre><p>The fix pyfirstaid gives is a habit worth learning anyway:</p><pre>python -m pip install requests</pre><p>python -m pip means “use the pip that belongs to <em>this</em> Python”. Groceries and cooking now happen in the same kitchen.</p><h3>2. “module ‘random’ has no attribute ‘randint’”</h3><p>Imagine a class with two kids named Ravi. The teacher calls “Ravi!”, and the wrong Ravi stands up.</p><p>When you write import random, Python looks for a module called random. And the <strong>first place it looks is the folder of your script</strong>. If you made a practice file called random.py there, Python happily loads <em>your</em> file instead of the real random module from the standard library. Your file has no randint, so you get a strange error.</p><p>This is called <strong>shadowing</strong>: your file hides a real module with the same name. It happens a lot with random.py, json.py, email.py and requests.py.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oO6q77WmRMtgtFCYfQN4EA.png" /><figcaption>Python checks your folder first, so your file can hide a real module.</figcaption></figure><p>Check it:</p><pre>python -m pyfirstaid --only shadowing</pre><p>pyfirstaid names the exact file. The fix is to rename it (for example my_random.py) and delete any __pycache__ folder next to it.</p><h3>3. “python3 –version” still shows the old version</h3><p>You installed a new Python. You open a terminal, type python3 --version, and it still shows the old one.</p><p>Think of a postman with a list of houses. He checks the list from the top and delivers to the first house with the right name, even if there is a newer house with the same name further down.</p><p>Your <strong>PATH</strong> works like that list. When you type python3, your computer searches the PATH folders from top to bottom and runs the <strong>first</strong> python3 it finds. If the old Python’s folder is higher up, it wins.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FneXiya-7M8qFHbf6ncZqg.png" /><figcaption>The first match on PATH wins, even if it is the wrong Python.</figcaption></figure><p>Check it:</p><pre>python3 -m pyfirstaid --only path,python-version</pre><p>This shows which Python python and python3 really start. It also warns about two common traps: Apple’s built-in Python on macOS, and the Microsoft Store shortcut on Windows. And it flags Pythons that are past end of life.</p><h3>4. “SSL: CERTIFICATE_VERIFY_FAILED” at work</h3><p>This one hits many of us in office networks. At home pip install works. At work it fails with an SSL error.</p><p>Short version: many companies have a security system (a proxy) that opens and re-seals your secure internet traffic, like a security desk that opens every letter and puts it in a new envelope. Python does not recognise the new seal, so it refuses.</p><pre>python -m pyfirstaid --only ssl</pre><p>This checks whether HTTPS to pypi.org works, whether a proxy is in the way, and whether your certificate settings point at real files. I will cover this one properly in Part 2.</p><h3>5. “ImportError” or “DLL load failed” after upgrading Python</h3><p>Some packages, like numpy, contain <strong>compiled</strong> parts. These are built for one exact Python version. It is like a phone charger made for an old phone model. After you upgrade the phone, the plug does not fit.</p><p>If you upgrade Python but keep old packages around, or an install was stopped halfway, you get errors like ImportError, undefined symbol, or DLL load failed.</p><pre>python -m pyfirstaid --only compiled,broken-installs</pre><p>You get the exact reinstall command for the package that is broken.</p><h3>A real run</h3><p>Here is a real run inside a project folder that has three problems on purpose. The venv’s Python is running, but pip belongs to the system Python, and a file called random.py sits in the folder.</p><pre>$ python -m pyfirstaid --share<br><br>pyfirstaid 0.2.0: checking your Python environment<br>Python 3.13.1 (~/project/.venv/bin/python)<br><br>✔ Python 3.13.1 (supported until October 2029)<br>✔ Virtual environment active: ~/project/.venv<br>✘ `pip` installs into a DIFFERENT Python<br>    pip    -&gt; /opt/homebrew/lib/python3.13/site-packages/pip (python 3.13)<br>    python -&gt; ~/project/.venv/bin/python (python 3.13)<br>    fix: Use `python -m pip install &lt;package&gt;` instead of `pip install`. If a virtual environment should be active, activate it first.<br>! Typing `python3` runs a DIFFERENT Python than this one<br>    python3 -&gt; /opt/homebrew<br>    this Python -&gt; ~/project/.venv<br>    fix: Activate the virtual environment you want, or call Python by its full path. To change the default, put the right Python&#39;s folder first in PATH.<br>✔ No PYTHONPATH / PYTHONHOME leaks<br>! `random.py` in this folder hides the standard library module `random`<br>    `import random` will load your file instead, which causes confusing errors like &quot;module &#39;random&#39; has no attribute ...&quot;.<br>    fix: Rename it (e.g. my_random.py) and delete any __pycache__ folder next to it.<br>✔ HTTPS to pypi.org works (OpenSSL 3.4.0 22 Oct 2024)<br>✔ 12 compiled package(s) match this Python<br>✔ No broken or duplicate installs (1 folder(s) scanned)<br>✔ No dependency conflicts (pip check)<br>✔ site-packages is writable<br>✔ Default text encoding is UTF-8<br><br>1 problem(s), 2 warning(s).</pre><p>Read it from top to bottom:</p><ul><li>The first two lines tell you <strong>which Python</strong> was checked. This alone solves half of the confusion.</li><li>The <strong>✘</strong> line is the two-kitchens problem from error 1, with both paths shown side by side.</li><li>The two <strong>!</strong> lines are the PATH problem (error 3) and the shadowing problem (error 2).</li><li>Every warning and problem ends with a <strong>fix:</strong> line you can copy.</li><li>--share replaced my home folder with ~, so this is safe to paste into a bug report.</li></ul><p>The program also returns an <strong>exit code</strong>, a number that scripts and CI tools can read:</p><ul><li>0 means no problems.</li><li>1 means problems were found.</li><li>2 means pyfirstaid itself failed.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pS-NDcsNFTyi_ynaezP_1A.png" /><figcaption>Green means fine, yellow means take a look, red means fix it now.</figcaption></figure><h3>All 12 checks at a glance</h3><p>You do not need to remember these. Run python -m pyfirstaid --list any time. But here is what it looks at:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bjmDD7EM9WbXAkfSTlTkxg.png" /><figcaption>pyfirstaid’s 12 checks, grouped like a doctor’s check-up.</figcaption></figure><ul><li><strong>Python and venv:</strong> python-version, venv, path, leaks</li><li><strong>Packages:</strong> pip-mismatch, shadowing, compiled, broken-installs, dependencies</li><li><strong>Network:</strong> ssl</li><li><strong>System:</strong> permissions, encoding</li></ul><h3>Why you can trust it</h3><p>I know it feels risky to run a stranger’s tool on your machine. So here is how it is built:</p><ul><li><strong>Zero dependencies.</strong> It uses only Python’s standard library. Python 3.9 or newer.</li><li><strong>Diagnose only.</strong> It never installs, deletes or changes anything.</li><li><strong>Works even when pip is broken.</strong> You can download a single file, pyfirstaid.pyz, from the GitHub releases page and run python pyfirstaid.pyz. No install needed.</li><li><strong>Privacy option.</strong> --share hides your username and home folder.</li><li><strong>Open source, MIT licence.</strong> The PyPI files are published straight from GitHub Actions, and PyPI shows the build proof (provenance) on the project page.</li><li><strong>Honest status.</strong> It is early (alpha), tested on Windows, macOS and Linux with Python 3.9 to 3.14. It does not cover conda yet (use conda doctor for that), or Poetry and pyenv specifics.</li></ul><h3>Tips and common mistakes</h3><ul><li><strong>Use </strong><strong>python -m pip install, not </strong><strong>pip install.</strong> This one habit prevents error 1 for good.</li><li><strong>Do not name your files after real modules.</strong> No random.py, json.py, test.py experiments in your project folder.</li><li><strong>Activate your venv before installing.</strong> If you forget, packages go into the wrong place.</li><li><strong>Installed pyfirstaid with pipx or </strong><strong>uv tool?</strong> Then it lives in its own private environment, and it checks the Python behind python3 (it tells you so). To check a project’s venv, point at it: pyfirstaid --python .venv/bin/python.</li><li><strong>Run only what you need.</strong> --only ssl,path runs some checks. --skip ssl skips some. --offline skips checks that need the internet.</li></ul><h3>Recap</h3><ul><li>Most “it works on my machine” problems are environment problems, not code problems.</li><li>pip install pyfirstaid, then python -m pyfirstaid, checks 12 common causes.</li><li>Every problem comes with a copy-paste fix, and nothing on your machine is changed.</li><li>python -m pip install and good file names prevent the two most common errors.</li></ul><h3>Try it and tell me what it found</h3><p>Run it once, even if nothing feels broken right now:</p><pre>pip install pyfirstaid<br>python -m pyfirstaid</pre><p>Then leave a comment with <strong>which check flagged something</strong> on your machine. I read every comment, and real cases decide which checks I build next.</p><p>If it helped you, a star on GitHub helps other people find it. And if you hit an environment error it does not catch yet, please open an issue with the error message.</p><ul><li>PyPI: <a href="https://pypi.org/project/pyfirstaid/">https://pypi.org/project/pyfirstaid/</a></li><li>GitHub: <a href="https://github.com/sai-sakalam/pyfirstaid">https://github.com/sai-sakalam/pyfirstaid</a></li><li>Where the idea started: <a href="https://discuss.python.org/t/standard-library-health-check-module/105153">https://discuss.python.org/t/standard-library-health-check-module/105153</a></li></ul><p><strong>Next in this series:</strong> Part 2, “Python at work”: fixing SSL errors behind company proxies, and making your CI fail early when the environment is broken.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d6ffb30dd5ec" width="1" height="1" alt=""><hr><p><a href="https://python.plainenglish.io/fix-5-python-setup-errors-with-one-command-d6ffb30dd5ec">Fix 5 Python Setup Errors With One Command</a> was originally published in <a href="https://python.plainenglish.io/">Python in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>