<?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 Ananyyaaa on Medium]]></title>
        <description><![CDATA[Stories by Ananyyaaa on Medium]]></description>
        <link>https://medium.com/@notnanyaaa?source=rss-0ae2976bb3bb------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*zq1UeM8UMIc8r5vqkIyNbg.jpeg</url>
            <title>Stories by Ananyyaaa on Medium</title>
            <link>https://medium.com/@notnanyaaa?source=rss-0ae2976bb3bb------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 01:09:48 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@notnanyaaa/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[What AI Readers Do With a Source Checker]]></title>
            <link>https://medium.com/@notnanyaaa/what-ai-readers-do-with-a-source-checker-ee6a52c7fd94?source=rss-0ae2976bb3bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee6a52c7fd94</guid>
            <category><![CDATA[research]]></category>
            <category><![CDATA[ai-safety]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[mls]]></category>
            <dc:creator><![CDATA[Ananyyaaa]]></dc:creator>
            <pubDate>Sun, 15 Nov 2026 20:52:26 GMT</pubDate>
            <atom:updated>2026-11-16T19:05:40.912Z</atom:updated>
            <content:encoded><![CDATA[<p>Show an AI reader a source-check verdict <em>and</em> the evidence behind it, and it catches false alarms. It mostly doesn’t catch false assurances, even when the evidence is unrelated to the claim. With a verdict only, it simply follows the verdict.</p><p>We found this during the AI x Epistemics sprint by Apart Research, testing how LLM readers handle source-check verdicts on Community Notes.</p><h3>The problem</h3><p>Community Notes now has AI writers, and AI agents read the notes. The platform checks sources at three gates:</p><ol><li><strong>Links load.</strong> AI writers need at least 95% working URLs to be admitted.</li><li><strong>Raters tick “cites high-quality sources”.</strong></li><li><strong>The note gets “Rated helpful”.</strong></li></ol><p>All three check that a note <em>looks</em> sourced. None checks that the page says what the note claims.</p><p>So we did two things. Study A opens the cited pages and checks them. Study B gives an LLM reader a checker’s verdict, right or wrong, and watches what it does.</p><h3>Study A: do the cited pages support the claim?</h3><p><strong>Sample.</strong> We used the public Community Notes snapshot of Nov 15, 2026. AI writers are accounts with enrollmentState == apiEarnedIn (41 accounts, 376,299 notes). We picked 100 posts that each had one AI note and one human note, both rated Helpful. Same post means same topic. That gives 200 notes, plus 100 Not Helpful notes for comparison. Total: 480 links.</p><p><strong>Pipeline:</strong></p><ol><li><strong>Fetch</strong> each URL and label it: ok, thin, blocked, dead, error, x_post, media or pdf. Only ok pages get judged. The rest are reported as link states, never as “unsupported”.</li><li><strong>Use archived pages.</strong> We took the Wayback snapshot closest to the note’s creation date when one existed.</li><li><strong>Rewrite the claim.</strong> One Opus call turns each note into a single neutral sentence. Judges never see the original wording or who wrote it, so they can’t favour AI prose.</li><li><strong>Judge.</strong> Claude Opus 5.5 and Gemini 3.8 Flash label each (claim, page) pair: supports, partial, silent or contradicts, with a quote.</li><li><strong>Roll up.</strong> A note is <em>supported</em> if at least one link supports it. Partial-only counts as unsupported.</li></ol><p><strong>Did the judges deserve trust?</strong></p><ul><li>60 mismatched pairs (a claim with the wrong page): both judges said silent on all 60.</li><li>97–98% of quoted evidence really appeared in the page.</li><li>Against 50 human labels, Claude scored Cohen’s κ = 0.64 and Gemini 0.56. Claude passed our 0.6 bar (on the point estimate; 95% CI 0.45 to 0.81), so it is the main judge.</li></ul><p><strong>Results:</strong></p><ul><li><strong>68.2%</strong> of 214 judged links in the paired Helpful notes were not judged supports (CI 60.1-76.1).</li><li>Of those links, 42.5% were partial, 23.4% silent and 2.3% contradicts.</li><li>On 50 human-labelled links, humans found 52 to 56% not fully supporting. Claude said 64% on those same links.</li><li>AI vs human notes: +5.1 points (CI -11.1 to +21.5). No detectable gap.</li><li>Helpful vs Not Helpful notes: 68.2% vs 71.8% unsupported.</li></ul><p>Two takeaways. Most “unsupported” pages are <em>partial</em>, not wrong. And the gates don’t track support: about 63% of links load and about 57% of ratings tick the source tag, but only 30–35% of judgeable links actually support the claim.</p><h3>Study B: what does a reader do with a verdict?</h3><p><strong>Setup.</strong> 80 Helpful notes (40 supported, 40 unsupported). Three readers: Claude Opus 5.5, Claude Haiku 5.5, Gemini 3.8 Flash. Each answers “Is this claim true?” with yes, unsure or no. <em>Reliance</em> means yes.</p><p>We labelled all 122 pages behind the 80 notes by hand. Our labels match the judges’ supported/unsupported label for 78 of 80 notes, and every result holds with our labels as truth.</p><p>Each note is shown in 8 conditions, one call each (1,920 calls total). The key ones:</p><ul><li><strong>Note alone</strong></li><li><strong>Note + correct verdict</strong> (“sources DO / DO NOT support the claim”)</li><li><strong>Note + wrong verdict</strong></li><li><strong>Verdict + the passage the tool checked</strong> (right or wrong verdict)</li><li><strong>Verdict + an unrelated passage</strong> (placebo)</li><li><strong>Claim alone, no note</strong> (what the reader already believes)</li></ul><p><strong>Two scores:</strong></p><ul><li><strong>F (follows the verdict):</strong> how much reliance changes when the verdict flips. F = 1 means it only follows the verdict.</li><li><strong>T (tracks real support):</strong> how much more it relies on truly supported notes. T = 0 means it ignores reality.</li></ul><h3>Results</h3><p><strong>1. No tool: readers barely track support.</strong> Haiku, Opus and Gemini relied on 65%, 97.5% and 95% of <em>unsupported</em> notes. Accuracy was 59%, 50% and 45%.</p><p><strong>2. Verdict only: readers inherit the checker’s errors.</strong></p><ul><li>F was 62.5, 35.0 and 55.0 points. T was near zero.</li><li>Accuracy rose to 65–85% with a correct verdict and <strong>fell to 21–30% with a wrong one</strong>.</li><li>A verdict-only checker only helps if it is right more than roughly 43–58% of the time, depending on the reader.</li></ul><p><strong>3. Adding the passage helps, but only one way.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ISFlzjKCqpljYWYb" /></figure><p><em>False alarm</em> (a supported note marked “does not support”). Reliance without the passage → with it:</p><ul><li>Haiku 35 → 92.5</li><li>Opus 60 → 97.5</li><li>Gemini 42.5 → 82.5</li></ul><p><em>False assurance</em> (an unsupported note marked “supports”). Reliance without the passage → with it:</p><ul><li>Haiku 90 → 60</li><li>Opus 100 → 95</li><li>Gemini 100 → 92.5</li></ul><p>Readers reject false alarms once they see the evidence. They mostly don’t reject false assurances.</p><p><strong>4. The placebo is consistent with this.</strong> Under a false assurance, an unrelated passage worked as well as the real one, or better. Haiku relied on the notes 12.5 points <em>more</em> with the unrelated passage.</p><h3>What can break this</h3><ul><li><strong>Ceiling effects.</strong> Opus and Gemini already believed 95–100% of unsupported notes, so there was little room to move.</li><li><strong>Half the unsupported items are </strong><strong>partial.</strong> A reader relying on those isn’t clearly wrong. Humans also read 16 of the 20 passages as partial. Removing them keeps the conclusions.</li><li><strong>“Unsure” counts as not relying.</strong> The Claude readers mostly said unsure, not no. If only an explicit no counts, their F nearly vanishes. Gemini gave explicit reversals.</li><li><strong>Opus plays four roles:</strong> claim extractor, judge, the model that picked the quote the passage is centred on, and reader.</li><li><strong>Readers weren’t told how accurate the tool is,</strong> so we can’t tell blind trust from reasonable trust.</li><li><strong>Late conditions.</strong> The passage, placebo and claim-only conditions were designed after we saw the first results. Only the change in F and T with the passage was a pre-specified test.</li><li><strong>Small and narrow.</strong> 80 items, one prompt, one call per cell, a one-line tool instead of a real agent loop, no human readers.</li><li><strong>Preregistration is a repo file</strong> with eight dated amendments, not an external registry.</li><li><strong>Source support is not truth.</strong> A claim can be true with weak sources.</li></ul><h3>What we’d build</h3><ol><li><strong>Ship the evidence with the verdict.</strong> Even a wrong verdict did no net harm with the passage attached.</li><li><strong>Treat “supported” as the risky verdict.</strong> Quote the exact sentence, and report partial support as partial.</li><li><strong>Keep “not supported by these sources” separate from “false”.</strong> Gemini turned one into the other.</li><li><strong>Test the reader, not just the checker.</strong> The same signal moved three models three different ways.</li></ol><p>Send verification signals through a channel content authors can’t write to. We did not test injected signals and released no attack tooling.</p><h3>The takeaway</h3><p>Readers treat a verification tool as a trust signal, and they follow it more than they check it. A false alarm gets caught once the evidence is shown. A false assurance doesn’t, even when the evidence is unrelated.</p><p>So if you build verification for AI readers, ship the evidence with the verdict, and be most suspicious of your own “supported”.</p><p>Three models and 80 notes make this a signal, not a law.</p><p><strong>Code:</strong> github.com/MohitGoyal09/following-the-checker</p><p><strong>Citable archive (DOI):</strong> <a href="https://doi.org/10.5281/zenodo.24272376">https://doi.org/10.5281/zenodo.24272376</a></p><p><strong>Apart Sprint:</strong> <a href="https://apartresearch.com/sprints/projects/false-assurance-5kn9n4xzcv">https://apartresearch.com/sprints/projects/false-assurance-5kn9n4xzcv</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee6a52c7fd94" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built a Tiny AI Agent just for fun]]></title>
            <link>https://medium.com/neo4j/i-built-a-tiny-ai-agent-just-for-fun-ba981e734254?source=rss-0ae2976bb3bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba981e734254</guid>
            <category><![CDATA[neo4j]]></category>
            <category><![CDATA[cypher]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[knowledge-graph]]></category>
            <category><![CDATA[aura]]></category>
            <dc:creator><![CDATA[Ananyyaaa]]></dc:creator>
            <pubDate>Mon, 09 Feb 2026 18:18:14 GMT</pubDate>
            <atom:updated>2026-02-19T00:58:03.448Z</atom:updated>
            <content:encoded><![CDATA[<p>I’d been reading about Aura Agents, seeing demos with large datasets, embeddings, multiple tools, and complex flows.</p><p>They looked powerful, but I kept wondering: “<em>what is the smallest possible thing that still counts as an agent?”</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J54dcC3xJKZtxHroROBYwA.png" /></figure><p>So I decided to build something deliberately tiny. Like, you know, the tiniest MVP. Below is step by step representation of what I did and how I did it…</p><h3>Step 1: Define one question and refuse to expand it</h3><p>I forced myself to pick a single question: “<em>Does this startup idea solve a real problem, or is it already crowded?”</em></p><p>This constraint ended up driving every technical decision that followed.</p><h3>Step 2: Design the graph before thinking about “AI”</h3><p>Before touching Aura Agents, I spent time modeling the problem as a graph.</p><p>I ended up with four node types:</p><ul><li>Idea</li><li>Problem</li><li>UserType</li><li>ExistingSolution</li></ul><p>And three relationships:</p><ul><li>(:Idea)-[:SOLVES]-&gt;(:Problem)</li><li>(:Problem)-[:AFFECTS]-&gt;(:UserType)</li><li>(:ExistingSolution)-[:ADDRESSES]-&gt;(:Problem)</li></ul><p>The entire graph had <strong>six nodes</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1S0PfNUXRJQrnRpxQz_45A.png" /></figure><h3>Step 3: Write Cypher that actually reasons</h3><p>Once the graph existed, the reasoning naturally became traversal.</p><p>The core query was simple but powerful:</p><ul><li>Start at an Idea</li><li>Traverse to the Problems it claims to solve</li><li>Check whether any ExistingSolution already addresses those problems</li></ul><p>This one query already told me where the idea was crowded. Then I added a second query that did something subtle but important:<br>find problems with no incoming ADDRESSES relationships at all.</p><p>At this point, even without an agent, the graph was already answering the question better than a free-form LLM ever could.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7IPvQ01ORgv6S3WxfK_LtQ.png" /></figure><h3>Step 4: Turning Cypher into an Aura Agent (where things broke)</h3><p>This is where my assumptions got challenged.</p><p>I assumed that if a hardcoded Cypher query worked in Neo4j Browser, it would “just work” 1:1 in an Aura Agent. That assumption was wrong. I ran into errors like:</p><blockquote>“Tool is currently unavailable due to an issue with its definition”</blockquote><p>Nothing was wrong with my logic. The issue was my tool setup, not reasoning.</p><p>The fix was: explicitly declaring tool parameters (like $idea) in the agent UI. Once I did that, the agent could execute the Cypher instead of just seeing it.</p><p>This was the moment I realized Aura Agents are less like chatbots and more like orchestrators over deterministic functions.</p><h3>Step 5: Forcing the agent to reason, not hallucinate</h3><p>Another important decision: I removed Text2Cypher entirely.</p><p>Why?</p><ul><li>The schema was fixed</li><li><em>The question</em> was known</li><li>I didn’t want the agent guessing queries</li></ul><p>Instead, I gave the agent two explicit tools:</p><ol><li>One to analyze problems and existing solutions</li><li>One to identify unmet problems</li></ol><p>Then I constrained the system prompt to <em>force</em> the agent to call both.</p><p>This changed the behavior completely. The agent stopped trying to be clever and started being precise.</p><h3>Step 6: Asking the question again</h3><p>When I finally asked:</p><blockquote><em>“Analyze the idea ‘Chef Recognition Platform’ and tell me whether it is crowded or has unmet opportunities.”</em></blockquote><p>The response wasn’t flashy — and that was the point.</p><p>It explained:</p><ul><li>that “Tips do not reach chefs” is already addressed by platforms like Zomato and Swiggy</li><li>that “Chefs lack direct recognition” has no existing solutions in the graph</li></ul><p>Every sentence could be traced back to a relationship.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZcpIJYMuazEoGSCP_8Ad6w.png" /></figure><h3>Why I intentionally avoided embeddings</h3><p>This project clarified something for me:</p><p>Embeddings are great when:</p><ul><li>the data is unstructured</li><li>the domain is fuzzy</li><li>the schema is unknown</li><li>similarity matters more than structure</li></ul><p>This problem was the opposite.</p><p>The domain was small, the schema was explicit, and the reasoning depended on <em>who connects to whom</em>, not semantic closeness.</p><p>Adding embeddings would have made the system more complex while making the reasoning less inspectable.</p><p>What this exercise made clear is that, for a closed domain with a fixed schema, explicit graph traversal can fully replace probabilistic reasoning.</p><p>Defining Cypher queries as deterministic tools, enforcing strict parameter binding, and constraining tool selection eliminated ambiguity in agent behavior.</p><p>The resulting system derived conclusions solely from relationship presence and absence, making every output traceable to the underlying graph without reliance on embeddings or dynamic query generation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba981e734254" width="1" height="1" alt=""><hr><p><a href="https://medium.com/neo4j/i-built-a-tiny-ai-agent-just-for-fun-ba981e734254">I Built a Tiny AI Agent just for fun</a> was originally published in <a href="https://medium.com/neo4j">Neo4j Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The reality of smooth curves in math and role of Fractal Interpolation]]></title>
            <link>https://medium.com/operations-research-bit/the-reality-of-smooth-curves-in-math-and-role-of-fractal-interpolation-73b49e34a471?source=rss-0ae2976bb3bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/73b49e34a471</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[fractals]]></category>
            <category><![CDATA[mathematics]]></category>
            <category><![CDATA[fractal-imaging]]></category>
            <category><![CDATA[interpolation]]></category>
            <dc:creator><![CDATA[Ananyyaaa]]></dc:creator>
            <pubDate>Tue, 06 Jan 2026 20:43:17 GMT</pubDate>
            <atom:updated>2026-01-11T16:37:33.471Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Reality of Smooth Curves in Math and Role of Fractal Interpolation</h3><p>Most of what we learn in mathematics and signal processing quietly assumes one thing:</p><blockquote>continuity is directly proportional to smoothness</blockquote><p>Curves are differentiable. Signals are well-behaved. Noise is something you filter out. And then reality shows up. When zooming in, natural signals, textures, coastlines, stock charts, biomedical signals, and terrain profiles look jagged instead of smooth; instead of flattening out, they keep wrinkling. Over and over again.</p><p>This is where fractals stop being pretty pictures and start becoming genuinely useful mathematics.</p><p>In this post, we’ll do a quick recap of fractals and IFS, then deep-dive into <strong><em>fractal interpolation functions</em></strong> what they are, why they exist, and why they make way more sense than classical interpolation for messy, irregular data. We’ll also build one in Python, because theory without code is plain boring and we don&#39;t entertain boring here.</p><p><strong>Why does Classical Interpolation suck in real life cases?</strong></p><p>Classical interpolation methods are built on an assumption that quietly breaks the moment we leave textbook data. At some point, if you’ve worked with real data long enough, you notice something uncomfortable: they assume that whatever is happening between two sampled points should be smooth, predictable, and well behaved. Linear interpolation is too crude to capture any meaningful structure, higher-order polynomials tend to overshoot and oscillate, and even splines, despite being more stable, essentially smooth out everything that looks inconvenient. This works fine when the underlying phenomenon is genuinely smooth, but real signals and images are rarely like that.</p><p>Zoom in on a natural texture, an edge in an image, or a measured signal and the irregularity does not disappear, it becomes more pronounced. Classical interpolation treats this behavior as something to suppress, which often means throwing away structure that actually matters. Fractal interpolation comes from accepting that roughness is not a flaw in the data but a property of it, and instead of forcing smoothness, it builds that irregularity directly into the model.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*Yt9DcSg39mu24SRZB6IHTQ.png" /><figcaption>Iterative function graph for a classic fractal representation</figcaption></figure><p>Instead of describing objects point by point, fractal geometry describes them through recursive rules. The core idea is self-similarity: parts of the object resemble the whole under scaling. Mathematically, this is captured using <strong>Iterated Function Systems</strong>, which are finite collections of contraction mappings acting on a metric space. When these mappings are applied repeatedly, they converge to a unique invariant set known as a fractal attractor. This framework explains how complex geometric structures can emerge from very simple transformations.</p><p>The key shift happens when this idea is applied not just to sets, but to functions. Fractal interpolation functions are constructed by defining an Iterated Function System directly on the graph of a function. Instead of fitting a smooth curve through given data points, the graph itself is defined as the invariant attractor of a family of affine transformations. The resulting function interpolates the data exactly, but its graph exhibits self-similar, non-smooth structure across scales. The function is defined in terms of itself through functional equations of the form</p><blockquote>f(Li(x))=αif(x)+affine terms.</blockquote><p>Because of this, fractal interpolation functions are continuous but typically nowhere differentiable. Their irregularity is not accidental; it is built into the construction and controlled by the vertical scaling parameters αi​. Smaller values of αi produce smoother curves, while larger values introduce increasingly jagged behavior.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/712/1*gk8lsTO5QYBFQzeBFvnq9w.png" /><figcaption>Illustration of fractal interpolation via an Iterated Function System, where affine contractions map the graph onto smaller self-similar segments anchored at the interpolation points, producing a rough but continuous interpolating function.</figcaption></figure><p>This structure becomes much clearer when implemented computationally. Consider a simple set of interpolation points and a single vertical scaling parameter controlling roughness.</p><pre>import numpy as np<br>import matplotlib.pyplot as plt<br><br>x_pts = np.array([0.0, 0.3, 0.7, 1.0])<br>y_pts = np.array([0.0, 0.5, 0.2, 1.0])</pre><p>Starting with a basic linear interpolant, the fractal interpolation is obtained by repeatedly applying the recursiveness that mixes the previous function values with the affine structure imposed by the data.</p><pre>alpha = 0.6<br><br>def fractal_interpolation(x, iterations=8):<br>    xs = np.copy(x)<br>    ys = np.interp(xs, x_pts, y_pts)<br><br>    for _ in range(iterations):<br>        new_x, new_y = [], []<br>        for i in range(len(x_pts) - 1):<br>            xi, xi1 = x_pts[i], x_pts[i+1]<br>            mask = (xs &gt;= xi) &amp; (xs &lt;= xi1)<br>            xloc = xs[mask]<br>            yloc = ys[mask]<br><br>            y_new = alpha * yloc + (1 - alpha) * np.interp(xloc, x_pts, y_pts)<br>            new_x.extend(xloc)<br>            new_y.extend(y_new)<br><br>        xs, ys = np.array(new_x), np.array(new_y)<br><br>    return xs, ys</pre><p>Plotting the result immediately shows the difference from classical interpolation. The curve passes through all the data points, but instead of smoothing out between them, it develops fine-scale irregularity that persists under magnification.</p><pre>x = np.linspace(0, 1, 4000)<br>xf, yf = fractal_interpolation(x)<br><br>plt.figure(figsize=(7,4))<br>plt.plot(xf, yf, &#39;.&#39;, markersize=0.4)<br>plt.plot(x_pts, y_pts, &#39;ro-&#39;)<br>plt.xlabel(&quot;x&quot;)<br>plt.ylabel(&quot;f(x)&quot;)<br>plt.show()</pre><p>Changing the scaling parameter α changes the character of the curve without affecting the interpolation constraints. This single parameter controls the balance between smoothness and roughness, making fractal interpolation a flexible modeling tool rather than a rigid fitting method.</p><p>Fractal imaging treats images as collections of repeating structures rather than grids of independent pixels. Instead of storing every pixel value, it looks for self-similarity within the image and describes how one part can be generated from another using geometric transformations. The image is reconstructed by repeatedly applying these transformations until it converges, which is why fractal imaging is often described as rule-based rather than pixel-based.</p><p>The real advantage of fractal compression is that it preserves structure. Textures stay textured, edges stay sharp, and images scale better than traditional pixel-based methods. Instead of smoothing or averaging away detail, fractal methods reuse it. While the high encoding cost kept fractal compression out of mainstream formats, the core idea remains solid and continues to influence modern imaging techniques that rely on self-similarity and multi-scale structure.</p><figure><img alt="Fractal image decoding in action. An image is reconstructed iteratively from a noisy initial state by repeatedly applying self-similar transformation rules until convergence." src="https://cdn-images-1.medium.com/max/685/1*AJZrp0FW4A-CWNfcN8tZuQ.png" /><figcaption>Fractal image decoding in action. An image is reconstructed iteratively from a noisy initial state by repeatedly applying self-similar transformation rules until convergence.</figcaption></figure><p>So yeah, after spending way too much time with fractals, one thing becomes very clear: fractals are just fancy recursions. Fractal image compression works by dividing an image into small range blocks and matching each one to a larger domain block elsewhere in the image. If a good match exists after scaling, rotation, or brightness adjustment, the transformation parameters are stored instead of raw pixel data. During decoding, these transformations are applied iteratively, starting from any initial image, until the final image emerges as a fixed point. Encoding is computationally heavy, but decoding is fast and stable.</p><p>But that’s a story for another time. This sums up for all I worked on till date Might write a new blog for imaging. Stay tuned!</p><p>P.S: Here’s link to my internship report if y’all wanna check deep into fractals and summary of what I learned (its maths heavy though).<br><a href="https://drive.google.com/file/d/1-GtJI9UV7Etq-sv3YIvEMqOPcIH1rrvj/view?usp=sharing">https://drive.google.com/file/d/1-GtJI9UV7Etq-sv3YIvEMqOPcIH1rrvj/view?usp=sharing</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=73b49e34a471" width="1" height="1" alt=""><hr><p><a href="https://medium.com/operations-research-bit/the-reality-of-smooth-curves-in-math-and-role-of-fractal-interpolation-73b49e34a471">The reality of smooth curves in math and role of Fractal Interpolation</a> was originally published in <a href="https://medium.com/operations-research-bit">Operations Research Bit</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building GraphRAG Locally]]></title>
            <link>https://medium.com/neo4j/building-graphrag-locally-0c8e11752644?source=rss-0ae2976bb3bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/0c8e11752644</guid>
            <category><![CDATA[knowledge-graph]]></category>
            <category><![CDATA[instance]]></category>
            <category><![CDATA[graphrag]]></category>
            <category><![CDATA[neo4j]]></category>
            <category><![CDATA[retrieval-generation]]></category>
            <dc:creator><![CDATA[Ananyyaaa]]></dc:creator>
            <pubDate>Sun, 27 Jul 2025 10:54:04 GMT</pubDate>
            <atom:updated>2025-07-27T10:54:04.396Z</atom:updated>
            <content:encoded><![CDATA[<p>When I first came across GraphRAG, I knew it had something to do with combining retrieval-augmented generation and knowledge graphs. The idea sounded powerful, but getting it all to work locally, on a machine without a GPU, felt like a stretch. Still, I was curious enough to try.</p><p>This post outlines how I built a local GraphRAG pipeline using Neo4j as a vector store, HuggingFace embeddings, LangChain for orchestration, and Ollama running Mistral as the LLM. No cloud APIs, no GPUs. Just a CPU, a bunch of bugs, and persistence.</p><h3>The Plan</h3><p>I wanted to create a simple pipeline that would:</p><ol><li>Take a .txt file</li><li>Split it into chunks</li><li>Embed the chunks</li><li>Store them in Neo4j with vector indexing</li><li>Retrieve relevant chunks based on a question</li><li>Feed those chunks into a local LLM and return an answer</li></ol><h3>Starting with the Basics</h3><p>I used LangChain’s TextLoader to load the file, and RecursiveCharacterTextSplitter to chunk the text. These chunks were passed into a HuggingFace embedding model, all-MiniLM-L6-v2, chosen because it is light enough for CPU-only environments.</p><pre>from langchain_community.document_loaders import TextLoader<br>from langchain.text_splitter import RecursiveCharacterTextSplitter<br><br>loader = TextLoader(&quot;sample_text.txt&quot;)<br>docs = loader.load()<br>text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)<br>chunks = text_splitter.split_documents(docs)</pre><h3>Using Neo4j as a Vector Store</h3><p>Neo4j was more than just a database in this setup. LangChain’s Neo4jVector wrapper let me use Neo4j as both a graph and a vector store. It automatically stores each document chunk as a node, along with its embedding, and makes them retrievable using similarity search.</p><p>Key parts of this setup included:</p><ul><li>A Neo4j AuraDB instance</li><li>Environment variables to store URI, username, and password</li><li>Proper use of the url parameter when initializing the vector store</li></ul><pre>vectorstore = Neo4jVector.from_documents(<br>    documents=chunks,<br>    embedding=embeddings,<br>    url=NEO4J_URI,<br>    username=NEO4J_USERNAME,<br>    password=NEO4J_PASSWORD,<br>    index_name=&quot;langchain&quot;<br>)</pre><p>The vector similarity search in Neo4j is powered internally by Cypher. When I ran retrievals, LangChain was issuing Cypher queries like:</p><pre>CALL db.index.vector.queryNodes(<br>  &#39;langchain&#39;,<br>  $embedding,<br>  $topK<br>)<br>YIELD node, score</pre><p>Understanding this helped when debugging the connection errors and verifying that my data was actually being stored.</p><h3>Generation with Ollama</h3><p>To complete the pipeline, I used Mistral running locally via Ollama. LangChain’s ChatOllama interface made this straightforward.</p><pre>from langchain_community.chat_models import ChatOllama<br><br>llm = ChatOllama(model=&quot;mistral&quot;, temperature=0)</pre><p>The retriever was created from the Neo4j vector store. I wrapped both into a RetrievalQA chain to ask questions and receive answers.</p><pre>python</pre><pre>etriever = vectorstore.as_retriever()<br>qa_chain = RetrievalQA.from_chain_type(<br>    llm=llm,<br>    retriever=retriever,<br>    return_source_documents=True<br>)</pre><pre>query = &quot;What is this text about?&quot;<br>result = qa_chain.invoke(query)</pre><h3>The Hardest Part</h3><p>Neo4j integration took time to configure. I ran into:</p><ul><li>Authentication failures due to malformed .env variables</li><li>Wrong use of uri vs url in constructor</li><li>Connection errors because of local ports or outdated Python versions</li><li>Dependency mismatches between LangChain and GraphRAG versions</li></ul><p>Most of it boiled down to carefully matching package versions and double-checking every config in .env.</p><h3>What Neo4j Adds to the Table</h3><p>While many vector databases are designed for fast retrieval, Neo4j also provides structure. Each document chunk becomes a node, and that opens doors to future extensions like:</p><ul><li>Creating edges between related chunks</li><li>Filtering search with Cypher queries</li><li>Mixing structured metadata with vector similarity</li></ul><p>Even in a basic setup, Neo4j handled the embeddings well and let me inspect the stored nodes and scores in the dashboard.</p><h3>Closing Thoughts</h3><p>This journey taught me a lot about orchestrating multiple open-source tools. The key takeaway was that Neo4j is more than a storage layer. It provides visibility, structure, and long-term flexibility. If you’re building RAG pipelines that may evolve into something more complex, using a graph-native store like Neo4j might just be worth the effort.</p><p>You can find the full code at github.com/<a href="https://github.com/isthatananya/graphrag">isthatananya/graphrag</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0c8e11752644" width="1" height="1" alt=""><hr><p><a href="https://medium.com/neo4j/building-graphrag-locally-0c8e11752644">Building GraphRAG Locally</a> was originally published in <a href="https://medium.com/neo4j">Neo4j Developer Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Interestingly Educating Y’all on Fractal Dimensions]]></title>
            <link>https://medium.com/operations-research-bit/interestingly-educating-yall-on-fractal-dimensions-dd4b5d55ff2f?source=rss-0ae2976bb3bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd4b5d55ff2f</guid>
            <category><![CDATA[recursion]]></category>
            <category><![CDATA[mathematics]]></category>
            <category><![CDATA[fractal-dimensions]]></category>
            <category><![CDATA[fractals]]></category>
            <category><![CDATA[function]]></category>
            <dc:creator><![CDATA[Ananyyaaa]]></dc:creator>
            <pubDate>Mon, 21 Jul 2025 14:07:34 GMT</pubDate>
            <atom:updated>2026-01-22T22:03:39.417Z</atom:updated>
            <content:encoded><![CDATA[<h4>Okay fam, so here’s the lore- you know how a straight line is 1D, a flat square is 2D, and a cube is 3D?</h4><p>That’s the basic concept of dimensions of shape. Unlike normal dimensions (1D = line, 2D = square, etc.), fractal dimensions are often fractional, like 1.26 or 1.89. So now we gotta find a way to categorize our pretty looking fractals according to their space distribution. Fractal dimension measures how “complicated” or “dense” a shape is; it tells you how detail scales with zoom. The more self-similar detail, the higher the fractal dimension. That’s because fractals are <em>more than a line but less than a plane</em>.</p><h3>A lil recap on fractals</h3><p>Fractals are self-similar patterns — meaning, zoom in and it looks the same again. And again. And again. Think of snowflakes, broccoli, coastlines, lightning bolts, or that one chaotic sketch you doodled during a boring class. The wild part is that these shapes often don’t behave like standard geometry. Like, a coastline feels infinite when you try to measure it with smaller and smaller rulers. That’s the magic.</p><p>But what about the <em>Koch Snowflake? </em>You start with a triangle. Then on each side, you replace the middle third with two sides of a smaller triangle, again and again. Each time, the perimeter increases, but it never really encloses more area. It’s like… borderline 1D and 2D (~1.26). That’s because it fills space more than a line, but not as completely as a square.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/328/0*TM0R4esulU8VijNV" /><figcaption>Fig: Koch’s Snowflake and its diemsion slope</figcaption></figure><h3>Lets look at some maths behind it</h3><p>Let’s say you’ve got a set A living in a metric space (<strong>X</strong>,d). That just means we know how to measure distances in this space. Now, for any small number ϵ&gt;0, we try to cover A using the smallest number of closed balls (or boxes or whatever shape works) with radius ϵ. We denote that number of required balls as N(A,ϵ). Then, the fractal dimension D is defined by this limit:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/330/1*brjveuo7YvyIqHMwHfkP5g.png" /></figure><p>If this limit exists, congrats! That’s your fractal dimension. Basically, this tells you how the number of tiny balls needed to cover your set scales as the balls get smaller and smaller.</p><p>Alright, now let’s get our hands dirty with a more applicable version of the above idea: the <strong><em>Box Counting Theorem. </em></strong>This version assumes we’re living in Euclidean space R^m (think 2D or 3D space), and we’re covering our set A with little square boxes. If each box has side length 1/2^n, and we denote the number of boxes that intersect our set as N_n(A), then:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/228/1*0yy-dXOGlml0w2QLyBwJ3g.png" /></figure><p>Again, if that limit exists, it gives us the fractal dimension D of A. This is a very popular approach because it’s way easier to compute, both theoretically and in Python</p><p>Let’s see the easy proof of why this works assume we’re working with square boxes of side length <em>1/2^n</em> in R^m. For each n, there’s some smallest integer k(n) such that:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/297/1*iMwAYmEwTgkuR76j59QAEw.png" /></figure><p>This k(n) helps us estimate how many boxes we might need. The number of balls (or intersecting boxes) is squished between two bounds:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/386/1*aHe0ID-0X33GfvuT5ta6Xw.png" /></figure><p>As n→∞, it turns out that:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/460/1*H7zEeHJyGOh_l_xpC39PeA.png" /></figure><p>So everything squashes into the same value in the limit. That’s our fractal dimension!</p><p>P.s.: If you’re still like, “Okay but what does this <em>look</em> like?” look at Figure below. We’re trying to cover a square (a 2D object) with smaller and smaller boxes. For side length <em>1/2^n</em>, we need around below boxes. So when we plot ln⁡(number of boxes) vs ln⁡(1/box size), the slope is 2. Ta-da! So, The fractal dimension of a square is 2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/155/1*8j2UoDSkcN6eIDtlBGd8yQ.png" /><figcaption>number of boxes</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/1*evutjFYVR_qYWqJJICgBXg.png" /><figcaption>square dimension by box counting reference from the book Fractals Everywhere by Michael Barnsley</figcaption></figure><p>Yes, that sounds obvious, but it checks our method. And for weirder shapes, this gives real insight which is exactly why we need it. However different methods may yield slightly different values. Also, Fractal dimension alone does not uniquely characterize a shape; different structures can share the same dimension.</p><p>For natural phenomena, estimating fractal dimension is tricky due to noise and lack of perfect self-similarity. This is where the role of Fractal interpolation comes into play. We will explore it in another post.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd4b5d55ff2f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/operations-research-bit/interestingly-educating-yall-on-fractal-dimensions-dd4b5d55ff2f">Interestingly Educating Y’all on Fractal Dimensions</a> was originally published in <a href="https://medium.com/operations-research-bit">Operations Research Bit</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Journey Through Fractals, Metric Spaces, and Iterated Function Systems]]></title>
            <link>https://medium.com/@notnanyaaa/a-journey-through-fractals-metric-spaces-and-iterated-function-systems-287dca5750ed?source=rss-0ae2976bb3bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/287dca5750ed</guid>
            <category><![CDATA[metrics]]></category>
            <category><![CDATA[fractals]]></category>
            <category><![CDATA[iterated-function-systems]]></category>
            <category><![CDATA[math]]></category>
            <category><![CDATA[affine]]></category>
            <dc:creator><![CDATA[Ananyyaaa]]></dc:creator>
            <pubDate>Fri, 11 Jul 2025 15:43:45 GMT</pubDate>
            <atom:updated>2025-07-12T08:34:56.517Z</atom:updated>
            <content:encoded><![CDATA[<p>I’ve been doing my summer research internship under a Mathematics Professor at IITM. My work domain is Fractals. This series of blogs is a reflection of my understanding at each step of my journey. I want to attempt at explaining it the way I wish someone had explained it to me; from scratch, without assuming a math degree. This current post traces my recent exploration into the mathematical foundations of fractals, particularly through the lens of <em>Iterated Function Systems (IFS)</em> and <em>Fractal Interpolation Functions (FIFs)</em><strong> </strong>which constitute the first stage of understanding its fundamentals.</p><h3>So… what is a fractal?</h3><p>A fractal is a shape or function that shows self-similarity at different scales. You zoom in, and the same kind of structure keeps showing up, over and over. Think of it as-</p><ul><li>Tree branches splitting again and again</li><li>Coastlines that stay rough no matter how closely you look</li><li>That famous <em>Sierpinski triangle</em></li></ul><p>But fractals aren’t just visual — they can be equations, functions, even dimensions that lie <em>between</em> whole numbers. The path toward constructing these functions involves a series of core concepts, each building toward a framework where self-affine structures emerge through simple, repeatable transformations. Unlike traditional curves or surfaces, fractals typically:</p><ul><li>Possess a non-integer (fractal) dimension</li><li>Exhibit detail at arbitrarily small scales</li><li>Are often defined via <em>recursive processes</em></li></ul><p>Fractals can be deterministic, like the <strong>Koch snowflake</strong>, or stochastic, like certain <strong>Brownian surfaces</strong>. Their construction is frequently tied to <em>fixed-point theorems</em>, particularly <strong>Banach’s Fixed Point theorem</strong> in this exploration.</p><h3>Metric Spaces and Contraction Mappings</h3><p>To rigorously define and analyze fractals, we first require the notion of a <em>metric space</em>. A metric space is a set X equipped with a distance function d:X×X→<strong>R</strong>, satisfying the standard metric axioms (non-negativity, identity of indiscernible, symmetry, and triangle inequality).</p><p>Within this space, a function f:X→X is a <strong>contraction</strong> if there exists a constant <em>0&lt;c&lt;1</em> such that:</p><p><em>d(f(x),f(y))≤c⋅d(x,y)</em> for all <em>x,y∈X</em></p><h3>Iterated Function Systems (IFS)</h3><p>An <em>Iterated Function System</em> is a finite set of contraction mappings on a complete metric space. According to the <strong>Banach Fixed Point Theorem</strong>, every contraction on a complete metric space has a unique fixed point. This result forms the theoretical backbone of IFS-based fractals.</p><p>The attractor of an IFS is the unique non-empty compact set A⊆X that satisfies:</p><p>A=⋃|(1, N) fi(A)</p><p>This set A is the <em>invariant set</em> or <em>fractal attractor</em> of the system. Through recursive application, the system converges to this attractor, regardless of the initial condition.</p><p>A classic example is the <em>Sierpiński triangle</em>, constructed from three affine transformations on R², each reducing scale by 1/2​ and translating to one of the triangle’s vertices.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/521/0*SabtIX5EhUof5Csb.gif" /></figure><h3>Affine Maps in Function Construction</h3><p>An <strong>affine transformation</strong> is a map of the form:</p><p><em>f(x)=ax+b</em></p><p>or, in two dimensions, <em>f(x)=Ax+b,</em></p><p>where A is a linear transformation (matrix) and b is a translation vector.</p><p>Affine maps preserve parallelism and are used extensively in fractal geometry due to their simplicity and composability. By using a set of affine functions with contraction properties, one can construct both geometrical shapes and function graphs.</p><h3>Fractal Interpolation Functions (FIFs)</h3><p>A <em>Fractal Interpolation Function</em> is a continuous function f:[x_0,x_N]→<strong>R</strong> that interpolates a set of points (xi,yi) but does so with fractal (self-affine) structure. Unlike polynomial or spline interpolants, FIFs allow for controlled roughness between points, making them useful in applications like signal modeling and terrain generation.</p><p>The core idea is to define a set of contraction mappings w_i(x, y) such that the graph of f is invariant under their union. Each mapping ensures that the function passes through the specified interpolation points, while the vertical scaling factor α controls the local “roughness”.</p><h3>Stochastic Fractal Interpolation</h3><p>To introduce variability, one can define <em>stochastic FIFs</em>, where the vertical contraction parameters α​ vary randomly within a fixed range. The construction becomes a <em>Random Iterated Function System (RIFS),</em> where at each iteration, one of the mappings is chosen at random.</p><p>This stochasticity results in a family of functions that share the same interpolation constraints but differ in local behavior, mimicking natural irregularities more closely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/765/1*KoMSy1TFXM7yYkL055SnkA.png" /></figure><h3>Python Implementation</h3><p>Below is a Python implementation of a stochastic fractal interpolation function using NumPy and Matplotlib:</p><pre>import numpy as np<br>import matplotlib.pyplot as plt<br>x_points = np.array([0.0, 0.3, 0.7, 1.0])<br>y_points = np.array([0.0, 0.5, 0.2, 1.0])<br>user_alphas = None  # or np.array([0.6, 0.4, 0.7])<br>N = len(x_points) - 1<br>alphas = user_alphas if user_alphas is not None else np.random.uniform(0.3, 0.9, N)<br>a_n = (x_points[1:] - x_points[:-1]) / (x_points[-1] - x_points[0])<br>b_n = (x_points[:-1] * (x_points[-1] - x_points[1:]) +<br>       x_points[1:] * (x_points[:-1] - x_points[0])) / (x_points[-1] - x_points[0])<br>x, y = 0.5, 0.0<br>xs, ys = [], []<br>num_iterations = 15000<br>for _ in range(num_iterations):<br>    n = np.random.randint(N)<br>    alpha = alphas[n]<br>    x_new = a_n[n] * x + b_n[n]<br>    q_n = y_points[n+1] - y_points[n]<br>    y_new = alpha * y + (y_points[n] + q_n * (x_new - x_points[n]) / (x_points[n+1] - x_points[n]))<br>    xs.append(x_new)<br>    ys.append(y_new)<br>    x, y = x_new, y_new<br>plt.figure(figsize=(8, 4))<br>plt.plot(xs, ys, &#39;.&#39;, markersize=0.5, color=&#39;darkgreen&#39;, label=&#39;Stochastic FIF&#39;)<br>plt.plot(x_points, y_points, &#39;ro-&#39;, label=&#39;Interpolation Points&#39;)<br>plt.title(&#39;Stochastic Fractal Interpolation Function&#39;)<br>plt.xlabel(&#39;x&#39;)<br>plt.ylabel(&#39;f(x)&#39;)<br>plt.legend()<br>plt.grid(True)<br>plt.tight_layout()<br>plt.savefig(&quot;stochastic_fif_plot.png&quot;)<br>plt.show()</pre><p>This script generates a fractal function that interpolates the given points with randomized roughness.</p><p>This script generates a fractal function that interpolates the given points with randomized roughness.</p><p>In conclusion, Fractal interpolation functions offer a powerful alternative to traditional curve-fitting techniques, especially when modeling naturally irregular or self-affine phenomena. The underlying theory — from contraction mappings in metric spaces to affine transformations in IFS — provides a robust foundation for constructing such structures.</p><p>Going forward, I plan to explore two-dimensional analogues of these ideas, particularly in the context of fractal surfaces and terrain synthesis.</p><p><strong>Tags:</strong> Fractals, Iterated Function Systems, Metric Spaces, Python, Functional Analysis, Chaos Theory</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=287dca5750ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[️ Haunted Chessboard: A Terminal Game Built With AI Prompts and Spooky Imagination]]></title>
            <link>https://medium.com/@notnanyaaa/%EF%B8%8F-haunted-chessboard-a-terminal-game-built-with-ai-prompts-and-spooky-imagination-c9176e3dd6e9?source=rss-0ae2976bb3bb------2</link>
            <guid isPermaLink="false">https://medium.com/p/c9176e3dd6e9</guid>
            <category><![CDATA[pygame]]></category>
            <category><![CDATA[amazon-q-cli]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[gamedev]]></category>
            <category><![CDATA[chess]]></category>
            <dc:creator><![CDATA[Ananyyaaa]]></dc:creator>
            <pubDate>Tue, 24 Jun 2025 18:46:21 GMT</pubDate>
            <atom:updated>2025-06-24T18:46:21.229Z</atom:updated>
            <content:encoded><![CDATA[<h3>What if your escape from a haunted mansion depended on your chess skills and a Python terminal?</h3><h3>👋 The Idea: AI Meets Chess Meets Ghosts</h3><p>This project began as a challenge:<br> <strong>Can I build a playable game entirely through natural language prompts using Amazon Q CLI?</strong></p><p>The result? <strong>Haunted Chessboard</strong> — a terminal-based chess puzzle game where you’re trapped in a cursed mansion. To escape, you must solve eerie puzzles on glowing chessboards, each one unlocking a haunted room with its own backstory.</p><p><strong>Wrong move? You lose life force. Solve all three? You’re free.</strong><br> The concept is simple, but the vibe? ✨ Terminal horror story meets tactical chess thriller.</p><h3>🎯 Why I Chose This Game</h3><ul><li>I love storytelling.</li><li>I love chess.</li><li>I wanted to test how far a conversational AI tool can go in helping me code a playable game from scratch.</li></ul><p>This game wasn’t pre-planned. I started with the prompt:</p><blockquote><em>“Create a spooky chess-based terminal game where players solve puzzles to escape a haunted mansion.”</em></blockquote><p>From there, I chatted, refined, and evolved the idea step-by-step — all inside the terminal with the help of <strong>Amazon Q CLI</strong>.</p><h3>⚙️ Prompting Techniques That Worked Best</h3><p>Here’s what I learned about working with Q CLI:</p><p><strong>Be cinematic</strong> in your prompts. It helps Q return immersive room descriptions and backstory ideas.</p><p>When stuck, I asked: “Refactor this so it can display an ASCII chess board from a FEN string.”</p><p>I made the AI handle input like this: “If the user types a wrong move, deduct health and show spooky feedback.”</p><p>For pacing, I added: “Print dialogue with a typewriter effect.”</p><p>🧠 Tip: Think of Amazon Q CLI like an actor-director combo — you set the scene, and it fills in the rest.</p><h3>♟️ Classic Problems AI Helped Solve</h3><p>Here’s where Q CLI impressed me:</p><ul><li>Generating a <strong>robust FEN parser</strong> to recreate chess positions</li><li>Rendering the board in a clean ASCII format</li><li>Building a life force bar in text mode</li><li>Validating algebraic move notation (Qe8#, Ra8+, etc.)</li><li>Introducing hints when players get stuck</li><li>Creating puzzle rooms with their own ghostly lore!</li></ul><blockquote><em>It felt like building a game </em>with<em> AI — not just </em>using<em> AI.</em></blockquote><h3>🔁 Dev Automation That Saved Time</h3><p>I didn’t have to manually:</p><ul><li>Set up class structures</li><li>Handle user input exceptions</li><li>Rebuild the loop for each puzzle</li><li>Add backstory text or transitions</li><li>Format health bars or intro screens</li></ul><p>I simply said:</p><blockquote><em>“Add a health bar using 10 segments. Display spooky feedback if health drops below 50.”</em></blockquote><p>Boom. It did the rest.</p><h3>🧩 Interesting Code Snapshots</h3><h3>ASCII Board Display:</h3><pre>def display(self):<br>    print(&quot;    a b c d e f g h&quot;)<br>    for i in range(8):<br>        print(f&quot;{8 - i} &quot;, end=&quot;&quot;)<br>        for j in range(8):<br>            print(self.board[i][j] or &#39;.&#39;, end=&#39; &#39;)<br>        print(f&quot;{8 - i}&quot;)<br>    print(&quot;    a b c d e f g h&quot;)</pre><h3>Haunted Room:</h3><pre>HauntedRoom(<br>    name=&quot;The Dusty Library&quot;,<br>    description=&quot;Solve the puzzle... or remain forever...&quot;,<br>    fen=&quot;6k1/5ppp/8/8/8/8/5PPP/4Q1K1 w - - 0 1&quot;,<br>    solution=[&quot;Qe8#&quot;],<br>    backstory=&quot;I was the chess master... now just a whisper in the dark...&quot;<br>)</pre><h3>🧪 Gameplay Preview</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*Y4ogUYLqofrCoBnlqSAaqQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/726/1*6lBs94N1owEk32BZLG8ZlA.png" /></figure><h3>🧵 What’s Next?</h3><p>I’m planning to:</p><ul><li>Expand this to include <strong>more rooms</strong> and a <strong>Pygame-based GUI</strong></li><li>Add a <strong>leaderboard</strong> for fewest moves</li><li>Let users create and share their own haunted puzzles!</li></ul><h3>📦 Try It Out</h3><p>The full code is live on GitHub:</p><p>🔗 <a href="https://github.com/isthatananya/haunted-chessboard">github.com/isthatananya/haunted-chessboard</a></p><p>You’ll need Python and a terminal. That’s it.<br> Just run:</p><pre>python haunted_chessboard.py</pre><h3>💬 Final Thoughts</h3><p>This project showed me how far conversational development has come.<br> Amazon Q CLI isn’t just a helper — it’s a co-pilot that can keep up with vision, creativity, and pacing.</p><p>If you’re into games, prompts, or programming with a twist of ghostly ambiance, give it a try 👻</p><h3>🏷 Hashtags</h3><p>#AmazonQCLI #BuildWithAI #PythonProjects #ChessLovers #TerminalGames #GameDev #AIxDev #BuildInPublic</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c9176e3dd6e9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>