<?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: Kiran Kumar S D</title>
    <description>The latest articles on DEV Community by Kiran Kumar S D (@kiran_kumarsd_cfbf3749a).</description>
    <link>https://dev.to/kiran_kumarsd_cfbf3749a</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%2F4217813%2F345d03c6-6817-4fad-bac2-78f8ca220286.jpg</url>
      <title>DEV Community: Kiran Kumar S D</title>
      <link>https://dev.to/kiran_kumarsd_cfbf3749a</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/kiran_kumarsd_cfbf3749a"/>
    <language>en</language>
    <item>
      <title>The tiny checklist that makes a handoff clearer</title>
      <dc:creator>Kiran Kumar S D</dc:creator>
      <pubDate>Tue, 17 Nov 2026 08:23:31 +0000</pubDate>
      <link>https://dev.to/kiran_kumarsd_cfbf3749a/the-tiny-checklist-that-makes-a-handoff-clearer-4lld</link>
      <guid>https://dev.to/kiran_kumarsd_cfbf3749a/the-tiny-checklist-that-makes-a-handoff-clearer-4lld</guid>
      <description>&lt;p&gt;Picture a Friday afternoon. Someone is going on leave Monday, so they write a quick message: "Flaky checkout test is mostly fixed, just needs a final look. Branch is up to date. Thanks!"&lt;/p&gt;

&lt;p&gt;On Monday, the person picking it up asks the obvious questions. Mostly fixed how? What does "final look" mean? Up to date with what? Forty minutes later, they are reading commit history to reconstruct what the message should have said.&lt;/p&gt;

&lt;p&gt;This is a hypothetical, but you have probably lived some version of it. Handoffs fail rarely because people are careless. They fail because the person handing off knows too much to notice what is missing.&lt;/p&gt;

&lt;p&gt;A short checklist fixes most of it. Here is the one I would use.&lt;/p&gt;

&lt;h2&gt;
  
  
  What counts as a handoff
&lt;/h2&gt;

&lt;p&gt;A handoff is any moment when work, or responsibility for it, moves from one person (or system) to another. That includes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;An engineer going on leave and passing a ticket to a teammate&lt;/li&gt;
&lt;li&gt;A developer passing a build to QA&lt;/li&gt;
&lt;li&gt;An on-call shift ending&lt;/li&gt;
&lt;li&gt;A prompt, agent workflow, or AI-generated draft passing to a human reviewer&lt;/li&gt;
&lt;li&gt;A QA lead passing release-readiness status to an engineering manager&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The common thread: the receiver lacks your context. Whatever is in your head and not on the page is gone.&lt;/p&gt;

&lt;h2&gt;
  
  
  The problem: context is invisible to the person who has it
&lt;/h2&gt;

&lt;p&gt;When you have worked on something for days, "the fix is in" feels like a complete sentence. You know which fix, in which file, tested how, and what remains risky. The reader knows none of it.&lt;/p&gt;

&lt;p&gt;Vague handoffs usually share the same gaps:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Status is a feeling, not a fact.&lt;/strong&gt; "Almost done" means different things to different people.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Next steps are implied.&lt;/strong&gt; The receiver has to guess what you would do next.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Risks live in your memory.&lt;/strong&gt; The weird edge case you noticed on Wednesday never got written down.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Links are missing.&lt;/strong&gt; The ticket, the branch, the failing run, the doc.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ownership is fuzzy.&lt;/strong&gt; Who decides if something is ambiguous?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;You do not need a long template to cover these. You need five questions.&lt;/p&gt;

&lt;h2&gt;
  
  
  The five-line checklist
&lt;/h2&gt;

&lt;p&gt;Copy this into a note, a PR template, or a team wiki page:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;1. State:   Where things stand right now (one sentence, factual)
2. Done:    What is finished and how it was verified
3. Next:    The very next action, and who owns it
4. Risks:   What could go wrong or is unknown
5. Links:   Where to find everything (ticket, branch, run, doc)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That is the whole thing. Each line exists because of a specific failure.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. State: one factual sentence
&lt;/h3&gt;

&lt;p&gt;Replace feelings with facts.&lt;/p&gt;

&lt;p&gt;Weak: "Mostly fixed."&lt;/p&gt;

&lt;p&gt;Better: "The checkout test passes locally in 10 of 10 runs, but I have not run it in CI yet."&lt;/p&gt;

&lt;p&gt;That sentence tells the receiver what is known and what is not. Notice that it also avoids claiming more than you checked. If you ran it ten times, say ten. If you ran it once, say once.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Done: what is finished and how you know
&lt;/h3&gt;

&lt;p&gt;"Done" without verification is a claim, not a status. Add the evidence in a few words:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;"Fixed the race condition in &lt;code&gt;waitForCart()&lt;/code&gt;. Verified by running the test in a loop locally."&lt;/li&gt;
&lt;li&gt;"Updated the API schema. Contract tests pass."&lt;/li&gt;
&lt;li&gt;"Drafted the release notes. Not reviewed by anyone yet."&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The last example matters. Saying what has &lt;em&gt;not&lt;/em&gt; been checked is just as useful as saying what has.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Next: the very next action, with an owner
&lt;/h3&gt;

&lt;p&gt;Not a roadmap. Just the next step.&lt;/p&gt;

&lt;p&gt;Weak: "Needs a final look."&lt;/p&gt;

&lt;p&gt;Better: "Next: run the test in CI three times on the &lt;code&gt;main&lt;/code&gt; merge queue. Owner: you, since I'm out. If it fails, check the network stub first."&lt;/p&gt;

&lt;p&gt;A good "next" line passes one test: could the receiver start working within five minutes of reading it?&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Risks: what you know and what you do not
&lt;/h3&gt;

&lt;p&gt;This is the line people skip, and it is the most valuable. Write down:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Known issues you chose not to fix&lt;/li&gt;
&lt;li&gt;Assumptions you made&lt;/li&gt;
&lt;li&gt;Things that surprised you&lt;/li&gt;
&lt;li&gt;Areas you did not test&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For example: "I assumed the payment sandbox is stable. It timed out once on Tuesday, so a CI failure could be that rather than my change."&lt;/p&gt;

&lt;p&gt;That one sentence can save an hour of debugging in the wrong place.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Links: make everything one click away
&lt;/h3&gt;

&lt;p&gt;List the ticket, branch or PR, failing and passing runs, relevant docs, and any dashboards. Do not make the receiver search for them.&lt;/p&gt;

&lt;p&gt;If a link requires access the receiver may not have, say so.&lt;/p&gt;

&lt;h2&gt;
  
  
  A full example
&lt;/h2&gt;

&lt;p&gt;Here is the vague Friday message rewritten with the checklist. Again, this is an illustrative scenario, not a real project.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Handoff: flaky checkout test

State: Test passes 10/10 locally after my change. Not yet run in CI.
Done:  Fixed a race in waitForCart() where the test clicked
       before the cart finished updating. Verified via local loop.
Next:  Run the test 3x in CI. Owner: Sam. If it fails, check the
       payment sandbox stub before touching my change.
Risks: Sandbox timed out once on Tuesday, so a CI failure may not
       be my fix. I did not test on the mobile viewport.
Links: Ticket QA-123 | Branch fix/checkout-race | Local run notes in PR description
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It takes about two minutes to write. It saves the receiver far more than that.&lt;/p&gt;

&lt;h2&gt;
  
  
  Using it with AI-assisted work
&lt;/h2&gt;

&lt;p&gt;The same checklist works when the handoff involves AI tooling, and it matters more there.&lt;/p&gt;

&lt;p&gt;Suppose a coding assistant generated a draft of a test suite and you are passing it to a teammate for review. The receiver needs to know things the output does not reveal on its own:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;State:&lt;/strong&gt; "Draft generated, lightly edited, not yet run against staging."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Done:&lt;/strong&gt; "Tests compile and pass locally. I read the assertions in the first three files only."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Next:&lt;/strong&gt; "Review the remaining files for assertions that check nothing meaningful."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Risks:&lt;/strong&gt; "Generated tests sometimes assert whatever the code currently does, including bugs. I did not compare against the spec."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Links:&lt;/strong&gt; The prompt or instructions used, the spec, the PR.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Being honest about what you reviewed and what you did not is the core of reliable AI-assisted work. A reviewer who thinks everything was checked will check less. A reviewer who knows exactly which parts were not checked will focus there.&lt;/p&gt;

&lt;p&gt;If you hand off a prompt or agent workflow, include the model or tool name, the instructions used, and any known failure patterns. "It sometimes invents field names in the schema" is a risk worth writing down.&lt;/p&gt;

&lt;h2&gt;
  
  
  For QA and engineering leaders
&lt;/h2&gt;

&lt;p&gt;If you manage a team, you can improve handoffs without adding process weight.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Put the checklist where handoffs already happen.&lt;/strong&gt; A PR template, a ticket field, or an on-call shift note. Do not create a new document nobody opens.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Keep it to five lines.&lt;/strong&gt; Longer templates get filled with filler.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Model it yourself.&lt;/strong&gt; If leaders write clear handoffs, others copy them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Review a bad handoff as a system problem.&lt;/strong&gt; Ask what the template failed to prompt, not who forgot.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For release-readiness handoffs from QA, the same shape works: state of testing, what was verified and how, what is next, known risks and untested areas, and links to the test runs. A line like "Regression passed; payments not covered this cycle" is more useful than "QA looks good."&lt;/p&gt;

&lt;h2&gt;
  
  
  Common mistakes
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Writing an essay.&lt;/strong&gt; The checklist is meant to be scannable. If a line grows past two sentences, trim it or link out.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Hiding bad news.&lt;/strong&gt; Risks are not an admission of failure. They are what makes the handoff trustworthy.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Skipping the owner.&lt;/strong&gt; "Someone should run this" means nobody will.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Treating it as paperwork.&lt;/strong&gt; If you fill it in after the fact just to comply, it loses its value. Write it while the context is still fresh, and ideally read it once as if you were the receiver.&lt;/p&gt;

&lt;h2&gt;
  
  
  A quick self-test
&lt;/h2&gt;

&lt;p&gt;Before sending, ask: &lt;em&gt;if I disappeared for two weeks, could the receiver continue without messaging me?&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;If the answer is no, find the missing line and add it. That one question catches most gaps.&lt;/p&gt;

&lt;h2&gt;
  
  
  Wrapping up
&lt;/h2&gt;

&lt;p&gt;Good handoffs are not about long documents. They are about moving the right five facts out of your head: where things stand, what is done and how you know, what happens next, what could go wrong, and where everything lives.&lt;/p&gt;

&lt;p&gt;Try it on your next handoff, even a small one. You will probably notice something you would have left out.&lt;/p&gt;

&lt;p&gt;What is the one detail you most often forget to include when passing work along? I would like to hear what you would add to the checklist.&lt;/p&gt;

</description>
      <category>management</category>
      <category>productivity</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>When a repeated task deserves a second look</title>
      <dc:creator>Kiran Kumar S D</dc:creator>
      <pubDate>Tue, 17 Nov 2026 08:23:18 +0000</pubDate>
      <link>https://dev.to/kiran_kumarsd_cfbf3749a/when-a-repeated-task-deserves-a-second-look-45l5</link>
      <guid>https://dev.to/kiran_kumarsd_cfbf3749a/when-a-repeated-task-deserves-a-second-look-45l5</guid>
      <description>&lt;p&gt;Most of us have a task we do so often that we stopped noticing it. Copying a failing test name into a ticket. Reformatting the same log output. Pasting the same checklist into every pull request.&lt;/p&gt;

&lt;p&gt;Here is a hypothetical to make it concrete. Imagine a QA engineer who, after every failed nightly run, opens the CI log, finds the failing tests, checks whether each one failed last night too, and posts a summary in a team channel. It takes fifteen minutes. It happens every morning. Nobody questions it because it's "just part of the job."&lt;/p&gt;

&lt;p&gt;That's the moment worth a second look.&lt;/p&gt;

&lt;h2&gt;
  
  
  The signal: repetition plus a stable pattern
&lt;/h2&gt;

&lt;p&gt;Not every repeated task deserves automation. Three questions help me decide:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Is the input predictable?&lt;/strong&gt; Does it come from the same place in roughly the same shape?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Are the steps mostly the same each time?&lt;/strong&gt; Or does each run need real judgment?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Is the cost of a mistake low or easy to catch?&lt;/strong&gt; A wrong summary is cheap. A wrong production change is not.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;If the answer is yes to all three, the task is a candidate. If the input is messy or the decision is high-stakes, keep a human in charge and use tooling only to assist.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step one: write the task down before touching code
&lt;/h2&gt;

&lt;p&gt;Before building anything, describe the task in plain steps. For the nightly-failure example:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Fetch the latest test report.&lt;/li&gt;
&lt;li&gt;List failed tests.&lt;/li&gt;
&lt;li&gt;Compare with the previous run.&lt;/li&gt;
&lt;li&gt;Label each as "new failure" or "still failing."&lt;/li&gt;
&lt;li&gt;Post a summary.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Writing it out often reveals that most of the work is mechanical. Only one step, working out &lt;em&gt;why&lt;/em&gt; something failed, needs a person.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step two: automate the boring part first
&lt;/h2&gt;

&lt;p&gt;A &lt;strong&gt;test report&lt;/strong&gt; here means a structured file, commonly JUnit XML, that most test frameworks can produce. Because it's structured, a small script can read it reliably. No AI needed.&lt;/p&gt;

&lt;p&gt;Here is an illustrative Python sketch:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;xml&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;etree&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ElementTree&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="no"&gt;ET&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;failed_tests&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;tree&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;ET&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;parse&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;failures&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;set&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="n"&gt;tree&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nb"&gt;iter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"testcase"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="k"&gt;case&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;find&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"failure"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;is&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="kc"&gt;None&lt;/span&gt; &lt;span class="ow"&gt;or&lt;/span&gt; &lt;span class="k"&gt;case&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;find&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"error"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;is&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="kc"&gt;None&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="n"&gt;failures&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;add&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s1"&gt;'{case.get("classname")}.{case.get("name")}'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;failures&lt;/span&gt;

&lt;span class="n"&gt;today&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;failed_tests&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"reports/today.xml"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;yesterday&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;failed_tests&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"reports/yesterday.xml"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;new_failures&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;sorted&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;today&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="n"&gt;yesterday&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;still_failing&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;sorted&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;today&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;yesterday&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"New failures:"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;new_failures&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;sep&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"\n  "&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Still failing:"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;still_failing&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;sep&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"\n  "&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is a sketch, not a drop-in tool. File paths, report layout, and how you store yesterday's report will differ in your setup. But the shape is the point: set comparison replaces a manual scan.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step three: ask where AI actually helps
&lt;/h2&gt;

&lt;p&gt;Once the mechanical work is scripted, look at what's left. In our example, it's the "why did this fail?" question.&lt;/p&gt;

&lt;p&gt;This is where a language model (an AI system that generates text from a prompt) can assist. You might pass it the error message and stack trace and ask for a short, plain-language hypothesis.&lt;/p&gt;

&lt;p&gt;A few practical rules:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Treat the output as a suggestion.&lt;/strong&gt; Models can sound confident and be wrong.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Send only what's needed.&lt;/strong&gt; Strip secrets, tokens, and customer data from logs before they leave your environment. Check your organization's policy first.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Keep the prompt narrow.&lt;/strong&gt; "Summarize this error in two sentences and list likely causes" beats "analyze this."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Label AI-generated text&lt;/strong&gt; in the summary so readers know it's a hypothesis.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;An example prompt:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;You are helping triage a failed automated test.
Given the error and stack trace below, write:
1. A two-sentence summary of what failed.
2. Up to three possible causes, most likely first.
Do not claim certainty. If the information is insufficient, say so.

Error:
{error_text}
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The last instruction matters. Asking the model to admit uncertainty reduces the chance of a tidy but misleading answer.&lt;/p&gt;

&lt;h2&gt;
  
  
  Step four: keep a quality check on the automation
&lt;/h2&gt;

&lt;p&gt;Automation is also code, so it needs the same care as anything else.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Test the parser with a known report, including an empty one and a malformed one.&lt;/li&gt;
&lt;li&gt;Make failures loud. A script that silently posts nothing is worse than no script.&lt;/li&gt;
&lt;li&gt;Review a sample of AI-written summaries periodically against what actually went wrong.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is the quality engineering mindset applied to your own tooling: if it saves time but can't be trusted, it hasn't saved anything.&lt;/p&gt;

&lt;h2&gt;
  
  
  When to leave it alone
&lt;/h2&gt;

&lt;p&gt;Sometimes the second look says "don't." If a task happens twice a year, the script costs more than it saves. If the task builds understanding you need, such as a new engineer reading logs to learn the system, automating it removes the learning. Repetition alone is not a reason.&lt;/p&gt;

&lt;h2&gt;
  
  
  A simple habit to start with
&lt;/h2&gt;

&lt;p&gt;Keep a running note of tasks you repeat. After a few weeks, scan it for ones that are frequent, predictable, and low-risk. Pick the smallest one and automate just the mechanical part.&lt;/p&gt;

&lt;p&gt;Which repeated task on your team have you stopped questioning, and what would a second look reveal?&lt;/p&gt;

</description>
      <category>automation</category>
      <category>devops</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Starting small: sharing what I learn in tech</title>
      <dc:creator>Kiran Kumar S D</dc:creator>
      <pubDate>Tue, 17 Nov 2026 08:01:31 +0000</pubDate>
      <link>https://dev.to/kiran_kumarsd_cfbf3749a/starting-small-sharing-what-i-learn-in-tech-29lh</link>
      <guid>https://dev.to/kiran_kumarsd_cfbf3749a/starting-small-sharing-what-i-learn-in-tech-29lh</guid>
      <description>&lt;p&gt;Most engineers I know have a folder somewhere called "notes" or "misc" or "stuff-to-remember." It holds a half-finished README, a few shell one-liners, and a config snippet that took three hours to get right. Nobody else has ever seen it.&lt;/p&gt;

&lt;p&gt;That folder is the starting line for sharing what you learn in tech. This article is about turning it into something public without needing a big idea, a big audience, or a big time commitment.&lt;/p&gt;

&lt;p&gt;I'm Kiran, and I focus on practical AI development, integrations, and engineering productivity, with a quality engineering mindset. That last part matters here, because sharing your work publicly is a quality problem too. You want it correct, reproducible, and useful to someone who isn't you.&lt;/p&gt;

&lt;h2&gt;
  
  
  The problem: learning that evaporates
&lt;/h2&gt;

&lt;p&gt;You solve a problem on Tuesday. By next quarter, you've half forgotten how. By next year, a teammate hits the same wall and spends the same three hours.&lt;/p&gt;

&lt;p&gt;Private learning has a short shelf life. Three things make it worse:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;You only remember the outcome, not the dead ends.&lt;/strong&gt; The dead ends are what other people need.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Explaining forces understanding.&lt;/strong&gt; If you can't write the steps down clearly, you probably don't understand them as well as you thought.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Teams lose knowledge silently.&lt;/strong&gt; It lives in chat threads and in the head of whoever fixed it last.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Sharing publicly is a way to fix all three at once. It doesn't have to be a conference talk. A short, accurate post is enough.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why starting small works
&lt;/h2&gt;

&lt;p&gt;The usual blocker is the belief that you need something original. You don't. You need something specific and correct.&lt;/p&gt;

&lt;p&gt;Compare two post ideas:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;"The future of AI in software testing"&lt;/li&gt;
&lt;li&gt;"How I structure a prompt so an LLM generates test cases in a consistent format"&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The first has been written thousands of times and no one can verify it. The second is narrow, testable, and useful to a particular reader on a particular afternoon.&lt;/p&gt;

&lt;p&gt;Small and specific beats broad and impressive. A reader can finish a small post, try the idea, and know whether it worked.&lt;/p&gt;

&lt;h2&gt;
  
  
  A simple framework: Problem, Attempt, Fix, Check
&lt;/h2&gt;

&lt;p&gt;When you're unsure how to structure a post, use four parts:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Problem:&lt;/strong&gt; What were you trying to do, and what went wrong?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Attempt:&lt;/strong&gt; What did you try first? Include what failed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fix:&lt;/strong&gt; What worked, and why do you think it worked?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Check:&lt;/strong&gt; How can the reader verify it on their own machine?&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The "Check" step is the quality engineering part. If a reader can't verify your claim, you've shared an opinion, not a lesson. Opinions are fine, but label them as opinions.&lt;/p&gt;

&lt;h2&gt;
  
  
  A worked example: a small, shareable lesson
&lt;/h2&gt;

&lt;p&gt;Let me walk through an illustrative example. This is a hypothetical scenario, not a report of a real project, but it shows the shape of a post worth writing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The scenario:&lt;/strong&gt; You ask a large language model (LLM) to generate test cases for a login form, and the output format changes every time. Sometimes it's a bullet list, sometimes a table, sometimes prose. That makes it impossible to feed into any tooling.&lt;/p&gt;

&lt;p&gt;A quick definition before the code: &lt;strong&gt;structured output&lt;/strong&gt; means asking the model to return data in a fixed format, such as JSON, so another program can read it reliably. Many LLM APIs now support some form of this, but the details vary by provider, so check your provider's current documentation rather than trusting any blog post, including this one.&lt;/p&gt;

&lt;h3&gt;
  
  
  Attempt: a vague prompt
&lt;/h3&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Write test cases for a login form.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The result is unpredictable. That's the problem, and it's worth showing in a post because it's what most people try first.&lt;/p&gt;

&lt;h3&gt;
  
  
  Fix: constrain the format and validate it
&lt;/h3&gt;

&lt;p&gt;First, make the prompt explicit about the shape you want:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;You are helping a QA engineer. Generate test cases for a login form
with fields: email, password, and a "Remember me" checkbox.

Return ONLY valid JSON, matching this shape:

{
  "test_cases": [
    {
      "id": "TC-001",
      "title": "short description",
      "steps": ["step 1", "step 2"],
      "expected": "expected result",
      "type": "positive | negative | boundary"
    }
  ]
}

Do not include any text outside the JSON.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Second, and this is the important part, don't trust the model to obey. Validate the output in code. Here's a small Python example using the standard library plus the &lt;code&gt;jsonschema&lt;/code&gt; package:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;
&lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;jsonschema&lt;/span&gt; &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;ValidationError&lt;/span&gt;

&lt;span class="no"&gt;SCHEMA&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"object"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="s2"&gt;"required"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"test_cases"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="s2"&gt;"properties"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="s2"&gt;"test_cases"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"array"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="s2"&gt;"minItems"&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="s2"&gt;"items"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
                &lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"object"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                &lt;span class="s2"&gt;"required"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"id"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"title"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"steps"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"expected"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                &lt;span class="s2"&gt;"properties"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
                    &lt;span class="s2"&gt;"id"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"string"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                    &lt;span class="s2"&gt;"title"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"string"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                    &lt;span class="s2"&gt;"steps"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"array"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"items"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"string"&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;span class="s2"&gt;"expected"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"string"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                    &lt;span class="s2"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"enum"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"positive"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"negative"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"boundary"&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;span class="p"&gt;}&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;span class="p"&gt;}&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;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;parse_test_cases&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;raw_text&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;list&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="kt"&gt;dict&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="n"&gt;data&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;loads&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;raw_text&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="nf"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;instance&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;schema&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="no"&gt;SCHEMA&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;except&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;JSONDecodeError&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;ValidationError&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;ValueError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"Model output failed validation: {err}"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"test_cases"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;What this does: &lt;code&gt;json.loads&lt;/code&gt; checks that the text is valid JSON. &lt;code&gt;validate&lt;/code&gt; checks that the JSON has the fields and types you expect. If either fails, you get a clear error instead of a silent bad result downstream.&lt;/p&gt;

&lt;h3&gt;
  
  
  Add a retry, with a limit
&lt;/h3&gt;

&lt;p&gt;Models sometimes return malformed output. A bounded retry handles that without looping forever:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;generate_with_retry&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;call_model&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;prompt&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;max_attempts&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;last_error&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;None&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;attempt&lt;/span&gt; &lt;span class="k"&gt;in&lt;/span&gt; &lt;span class="nb"&gt;range&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="n"&gt;max_attempts&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;raw&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;call_model&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;prompt&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="nf"&gt;parse_test_cases&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;raw&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;except&lt;/span&gt; &lt;span class="nc"&gt;ValueError&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="n"&gt;last_error&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt;
            &lt;span class="n"&gt;prompt&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
                &lt;span class="n"&gt;prompt&lt;/span&gt;
                &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="s2"&gt;"\n\nYour previous reply was invalid: "&lt;/span&gt;
                &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;err&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="s2"&gt;"\nReturn only valid JSON matching the schema."&lt;/span&gt;
            &lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;RuntimeError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"Gave up after {max_attempts} attempts: {last_error}"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Here &lt;code&gt;call_model&lt;/code&gt; is whatever function wraps your provider's API. Keeping it as a parameter means you can swap providers and, more usefully, test this logic with a fake.&lt;/p&gt;

&lt;h3&gt;
  
  
  Check: test your own code
&lt;/h3&gt;

&lt;p&gt;A post is stronger when the reader can run something. Here's a test that needs no real model:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;test_retry_recovers_after_bad_output&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;span class="n"&gt;replies&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;iter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;
        &lt;span class="s2"&gt;"Sure! Here are some tests..."&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;  &lt;span class="c1"&gt;# invalid&lt;/span&gt;
        &lt;span class="s1"&gt;'{"test_cases": [{"id": "TC-001", "title": "valid login",'&lt;/span&gt;
        &lt;span class="s1"&gt;' "steps": ["enter creds"], "expected": "dashboard shown",'&lt;/span&gt;
        &lt;span class="s1"&gt;' "type": "positive"}]}'&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;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;generate_with_retry&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;lambda&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;next&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;replies&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"prompt"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"id"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"TC-001"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The first reply is deliberately broken. The test confirms the second attempt gets accepted. That's a verifiable claim a reader can reproduce in a minute.&lt;/p&gt;

&lt;h2&gt;
  
  
  What made that a good post
&lt;/h2&gt;

&lt;p&gt;Look at what the example did, because the pattern transfers to almost any topic:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;It named a narrow problem.&lt;/strong&gt; Inconsistent LLM output, not "AI in testing."&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It showed the naive attempt.&lt;/strong&gt; Readers recognize their own first try.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It validated instead of trusting.&lt;/strong&gt; Model output is untrusted input, like any user input.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It included a check.&lt;/strong&gt; The reader can confirm it works.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It stayed honest about limits.&lt;/strong&gt; It pointed to provider docs instead of claiming universal behavior.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Notice what it didn't include: made-up numbers like "this improved our accuracy by 40%." Without a real measurement, that sentence is fiction. If you have real data, share it and describe how you measured it. If you don't, say what you observed and leave it there.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to find topics when you think you have none
&lt;/h2&gt;

&lt;p&gt;You don't need to brainstorm. Mine what you already did this week.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Look at your terminal history.&lt;/strong&gt; Commands you ran twice are candidates.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Look at your pull request comments.&lt;/strong&gt; Questions reviewers asked often point to non-obvious knowledge.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Look at your bug tracker.&lt;/strong&gt; A bug with a surprising cause makes a good post.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Look at what you searched for.&lt;/strong&gt; If you searched for it, others will too.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Look at what you explained out loud.&lt;/strong&gt; Anything you've explained to a teammate twice deserves writing down once.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A useful filter: would this have saved me an hour a month ago? If yes, write it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Rules for sharing safely
&lt;/h2&gt;

&lt;p&gt;Public writing comes with a responsibility that private notes don't. A few non-negotiables:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Never publish private information.&lt;/strong&gt; That includes API keys, tokens, internal hostnames, customer names, proprietary code, and anything covered by your employer's confidentiality terms. Rebuild the example from scratch with fake data instead of sanitizing the real thing. Sanitizing is where leaks happen.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Check your employer's policy.&lt;/strong&gt; Many companies have guidelines on external writing. Read them before your first post, not after.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Label hypotheticals.&lt;/strong&gt; If an example is illustrative, say so. Readers trust you more when you're clear about what's real.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cite what you didn't discover.&lt;/strong&gt; If you're reporting a recent AI update, link the primary source, such as the official release notes or documentation. Don't rely on a screenshot or a secondhand summary. If you can't find a source, don't state it as fact.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Date your technical claims.&lt;/strong&gt; AI tooling changes fast. A line like "tested with version X on this date" helps readers judge whether your advice still applies.&lt;/p&gt;

&lt;h2&gt;
  
  
  A lightweight publishing routine
&lt;/h2&gt;

&lt;p&gt;Consistency matters more than volume. Here is a routine that fits around a full-time job:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Keep a running list.&lt;/strong&gt; One line per idea, added the moment it occurs to you.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pick one idea a month.&lt;/strong&gt; Not five. One.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Write the code first.&lt;/strong&gt; Get the example working and tested before you write a word of prose.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Draft in one sitting.&lt;/strong&gt; Aim for 600 to 1,200 words. Edit later.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Run it past the checklist.&lt;/strong&gt; Is it accurate, reproducible, and free of private data?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Publish, then leave it.&lt;/strong&gt; Don't refresh the stats every ten minutes.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;If you lead a team, you can make this a shared habit. A short internal write-up after each notable fix builds a searchable record, and the best ones can be rewritten for the public with fake data.&lt;/p&gt;

&lt;h2&gt;
  
  
  Handling the fear
&lt;/h2&gt;

&lt;p&gt;Most people worry about being wrong in public. That's reasonable, and it's actually a good instinct to channel.&lt;/p&gt;

&lt;p&gt;Being wrong occasionally is survivable, especially if you correct it openly. Add an update note, fix the code, and thank the person who flagged it. Readers respect that more than a flawless-looking post that quietly changed.&lt;/p&gt;

&lt;p&gt;The other fear is that your topic is too basic. Basic topics, explained clearly, are what most readers need. Experts rarely search for fundamentals, but the many engineers who aren't experts in your particular area do.&lt;/p&gt;

&lt;h2&gt;
  
  
  A pre-publish checklist
&lt;/h2&gt;

&lt;p&gt;Before you hit publish, run through this:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;[ ] Does the post solve one specific problem?&lt;/li&gt;
&lt;li&gt;[ ] Are jargon terms explained before they're used?&lt;/li&gt;
&lt;li&gt;[ ] Does every code sample run as written?&lt;/li&gt;
&lt;li&gt;[ ] Is there a way for the reader to verify the result?&lt;/li&gt;
&lt;li&gt;[ ] Are hypothetical examples labeled as hypothetical?&lt;/li&gt;
&lt;li&gt;[ ] Are all numbers and claims either measured by you or linked to a source?&lt;/li&gt;
&lt;li&gt;[ ] Is every secret, customer detail, and internal name removed?&lt;/li&gt;
&lt;li&gt;[ ] Does it mention the versions and date it applies to?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you can check every box, publish it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;Sharing what you learn doesn't require expertise at the level of a famous speaker. It requires noticing what you figured out, writing it down accurately, and giving the reader a way to check your work.&lt;/p&gt;

&lt;p&gt;Start with the folder of notes. Pick the one item that cost you the most time. Write it up as Problem, Attempt, Fix, Check. Build the example from scratch with fake data, test it, and publish it.&lt;/p&gt;

&lt;p&gt;That single post will help a future teammate, a stranger with the same bug, and you, six months from now, when you've forgotten how you solved it.&lt;/p&gt;

&lt;p&gt;So here's my question for you: what's the one thing you figured out in the last month that you wish had been easier to find? That's probably your first post.&lt;/p&gt;

</description>
      <category>beginners</category>
      <category>learning</category>
      <category>productivity</category>
      <category>writing</category>
    </item>
  </channel>
</rss>
