<?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 TanyaGupta on Medium]]></title>
        <description><![CDATA[Stories by TanyaGupta on Medium]]></description>
        <link>https://medium.com/@tanyasanskriti08?source=rss-5ba65246b5d3------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*vCKU0YDX_bTiF5VUXLLmbA.png</url>
            <title>Stories by TanyaGupta on Medium</title>
            <link>https://medium.com/@tanyasanskriti08?source=rss-5ba65246b5d3------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 01:09:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@tanyasanskriti08/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[Two LeetCode Problems, A Few Mistakes, and Lessons Beyond the Code]]></title>
            <link>https://tanyasanskriti08.medium.com/two-leetcode-problems-a-few-mistakes-and-lessons-beyond-the-code-4c6d272e45d4?source=rss-5ba65246b5d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c6d272e45d4</guid>
            <category><![CDATA[sad]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[mls]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[TanyaGupta]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 11:34:03 GMT</pubDate>
            <atom:updated>2026-11-19T11:34:03.242Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6hw_FC2_01CR3nzn" /><figcaption>Photo by <a href="https://unsplash.com/@cdr6934?utm_source=medium&amp;utm_medium=referral">Chris Ried</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><em>Sometimes, solving a problem teaches you more about your approach than the actual concept.</em></p><p>As I continue practising Data Structures and Algorithms using Java, I have been trying to pay more attention to something beyond just getting an accepted submission: understanding how I approach a problem, where my logic goes wrong, and what I could have done differently.</p><p>Recently, while working on two LeetCode problems, I came across a few interesting situations that made me revisit some basic concepts.</p><p>The problems weren’t necessarily difficult, but the little mistakes I made while solving them were worth documenting.</p><h3>1. Valid Palindrome — When I misunderstood the requirements</h3><p>The first problem I want to talk about is <strong>LeetCode 125: Valid Palindrome</strong>.</p><p>The task is to check whether a given string reads the same forward and backward after converting uppercase letters to lowercase and removing all non-alphanumeric characters.</p><p>My initial approach was quite simple:</p><ul><li>Remove special characters.</li><li>Convert the remaining characters into lowercase.</li><li>Reverse the string.</li><li>Compare both strings.</li></ul><p>I thought I had understood the problem, but implementing the logic brought out a few gaps in my understanding.</p><p><strong>What I misunderstood:</strong></p><p><strong>Checking the index instead of the character</strong></p><p>I was trying to compare punctuation marks using the loop variable i. I overlooked the fact that i represents an index, not the actual character. Using charAt(i) helped me understand the difference.</p><p><strong>Removing only selected special characters</strong></p><p>Initially, I was thinking about commas, spaces and colons individually. However, the question required removing every character that wasn’t a letter or digit. That’s when I came across Character.isLetterOrDigit().</p><p><strong>Missing the first character</strong></p><p>My loop condition was i &gt; 0, which meant index 0 was never included. A small change to i &gt;= 0 fixed that.</p><p><strong>Comparing strings in Java</strong></p><p>I also revisited the difference between == and .equals(). For comparing string contents, .equals() was what I needed.</p><p>What looked like a straightforward string problem turned into a useful revision of Java fundamentals.</p><h3>2. Best Time to Buy and Sell Stock — When correct logic wasn’t enough</h3><p>The next problem was <strong>LeetCode 121: Best Time to Buy and Sell Stock</strong>.</p><p>We are given an array of stock prices, where each element represents the price on a particular day. We need to find the maximum profit by buying first and selling on a later day.</p><p>For example:</p><p>prices = [7, 1, 5, 3, 6, 4]</p><p>The best choice is to buy at 1 and sell at 6.</p><p>Maximum profit = 6–1 = 5.</p><h3>My first approach</h3><p>I decided to use nested loops.</p><p>One loop would represent the buying day, while the second would represent the selling day. I calculated the difference between the two prices and updated the maximum profit whenever I found a better result.</p><p>The logic seemed fine, so I submitted it.</p><p>And then I got:</p><p><strong>Time Limit Exceeded — 202/213 test cases passed.</strong></p><p>That result made me pause.</p><p>I initially wondered whether I had missed a condition or made a calculation error. But the problem wasn’t the subtraction or the profit calculation.</p><p>It was the time my approach took.</p><p>My nested loops were checking almost every possible buying and selling combination. For a large input, that meant too many operations.</p><p>The time complexity was O(n²).</p><h3>Rethinking the approach</h3><p>Instead of checking every possible combination, I started thinking about what information I actually needed.</p><p>I realised I only needed to keep track of two things:</p><ul><li>The minimum price encountered so far.</li><li>The maximum profit calculated so far.</li></ul><p>By updating these values while traversing the array once, I could avoid the repeated comparisons.</p><p>This brought the time complexity down from O(n²) to O(n).</p><p>The interesting part wasn’t just getting a better solution. It was understanding why my previous solution struggled.</p><h3>3. A Few Things Worth Remembering</h3><p>Working through these problems reminded me of a few things:</p><p><strong>Understanding comes before implementation.</strong></p><p>Sometimes, I start thinking about the code before completely understanding what the question expects. Reading the requirements carefully can save a lot of unnecessary debugging.</p><p><strong>Small mistakes can change the entire output.</strong></p><p>A wrong loop condition or comparing an index instead of a character might seem minor, but it can affect the entire solution.</p><p><strong>Correctness and efficiency are different things.</strong></p><p>The stock problem made this particularly clear. My approach was producing correct answers for many test cases, but that didn’t make it efficient enough.</p><p><strong>Revisiting basics is not a step backwards.</strong></p><p>Concepts like loops, strings, arrays and comparisons are the foundation of solving larger problems. There is no harm in revisiting them whenever necessary.</p><h3>4. What I’m Taking Forward</h3><p>I don’t want to measure my DSA practice only by the number of problems I solve or the number of green Accepted submissions I collect.</p><p>I want to understand my own thinking process.</p><p>Why did I choose a particular approach? What did I overlook? Could I have solved it differently? And most importantly, can I explain the logic without simply memorising the code?</p><p>These are the questions I’m trying to ask myself more often.</p><p>There will be problems where my first approach works, and others where I’ll have to rethink everything. Both are part of the process.</p><p><strong>Because sometimes, the most useful part of solving a problem is discovering what you didn’t understand while solving it.</strong></p><p>More problems to explore, more concepts to revisit, and more lessons to document.</p><p><em>Learning, debugging and improving — one problem at a time.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c6d272e45d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Java Lifeline: Surviving the Chaos and Interruptions of an Engineering Degree…]]></title>
            <link>https://tanyasanskriti08.medium.com/the-java-lifeline-surviving-the-chaos-and-interruptions-of-an-engineering-degree-cd684e2ebdfb?source=rss-5ba65246b5d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd684e2ebdfb</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[daily-life]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[college]]></category>
            <dc:creator><![CDATA[TanyaGupta]]></dc:creator>
            <pubDate>Sun, 01 Nov 2026 12:44:54 GMT</pubDate>
            <atom:updated>2026-11-01T12:44:54.512Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oLImRzbxhxePg-tA" /><figcaption>Photo by <a href="https://unsplash.com/@thisisengineering?utm_source=medium&amp;utm_medium=referral">ThisisEngineering</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Let’s talk about the actual reality of being an engineering student right now. If you look online, it is all aesthetic coding setups and people mastering five different frameworks before breakfast. In reality? It is a chaotic, overwhelming maze of way too many programming languages. Just when you think you are getting the hang of one, the industry — or your curriculum — throws a completely different syntax at you. It is confusing, and frankly, it is exhausting.</p><p>But I came into this chaos with a secret weapon.</p><p>As a perk of coming from the ISC board, I was introduced to the basics of Java right from the beginning. While a lot of people were wrestling with basic syntax, object-oriented concepts, and figuring out how a simple loop works, I already had that foundation locked in. That early exposure to Java has been an absolute lifesaver.</p><p>Because I already understood the core logic, diving into Data Structures and Algorithms (DSA) wasn’t a nightmare. I didn’t have to fight the programming language; I just had to focus on the actual problem-solving. I got into a really solid groove, tackling problems on a daily basis and building that muscle memory. You know that incredible feeling when the logic just <em>clicks</em> and your code executes perfectly? That was becoming my daily routine.</p><p>Then, the ultimate villain of every engineering student’s life arrived: college exams.</p><p>There is nothing more irritating than having a perfect DSA streak derailed because you suddenly have to drop everything to cram for midterms. The context switching is absolutely brutal. You go from optimizing time complexities and traversing trees to memorizing syllabus material that you will likely forget the minute you walk out of the exam hall. It completely breaks your daily practice, kills your momentum, and getting that rhythm back afterward feels like starting from scratch. It is intensely frustrating to have your real skill-building interrupted by routine exams.</p><p>But I am starting to realize that this is exactly what the engineering life actually is. It is not a perfect, uninterrupted montage of writing code. It is learning to navigate the sheer volume of confusing languages, leaning hard on your early foundations, and somehow finding the discipline to get back to your daily DSA grind the second those exams are finally over.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd684e2ebdfb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Under the Library’s Watchful Eye: Surviving 9 Hours, 9-to-5s, and the Guilt of a Single Reel]]></title>
            <link>https://tanyasanskriti08.medium.com/under-the-librarys-watchful-eye-surviving-9-hours-9-to-5s-and-the-guilt-of-a-single-reel-92d31fb3dc7d?source=rss-5ba65246b5d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/92d31fb3dc7d</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[books]]></category>
            <category><![CDATA[education]]></category>
            <category><![CDATA[writing]]></category>
            <category><![CDATA[women]]></category>
            <dc:creator><![CDATA[TanyaGupta]]></dc:creator>
            <pubDate>Thu, 22 Oct 2026 16:24:47 GMT</pubDate>
            <atom:updated>2026-10-22T16:24:47.036Z</atom:updated>
            <content:encoded><![CDATA[<p>There is a very specific kind of paranoia that only a silent library reading room can manufacture.</p><p>In the beginning, I hated this place. It was too loud with its quietness. People walking by, chairs scraping against the floor, low whispers, and the constant urge to look up from my laptop every time someone breathed too heavily. I thought it was just a distraction.</p><p>Now? Now, if I dare open Instagram and mindlessly scroll through five reels, my guilt develops eyes, ears, and an entire surveillance network. I suddenly become convinced that every single person in a three-row radius—heads buried in thick textbooks, furiously typing code, or drowning in existential dread—knows I am looking at a dog video.</p><p>Nobody is actually watching. But under the weight of the silence, a simple swipe feels like a public offense.</p><p>The 9-to-5 Grind and the 11 PM Finish Line</p><p>Let’s be honest: my daily routine has become a bit unhinged.</p><p>College runs from 9:00 AM to 5:00 PM. Most people use the evening to decompress, grab a coffee, or stare at a wall. Me? I pack up my laptop, put my headphones on, and run straight to the library. There is no resting phase. There is only the transition from one form of exhaustion to another.</p><p>By the time night falls and the clock hits 11:00 PM, packing my bag feels less like organizing my belongings and more like submitting the final, grueling assignment of the day. My shoulders ache, my brain feels like fried circuitry, and the walk back home is a blur.</p><p>It’s hectic, it’s demanding, and some days it feels completely absurd. Some evenings start with a meticulously color-coded plan to conquer the universe. Other evenings? I am just staring blankly at a blinking cursor, desperately praying the code finally makes sense before security kicks me out.</p><p>The Shared Gravity of Hustle</p><p>Yet, despite the madness, something keeps pulling me back through these glass doors.</p><p>There is an invisible pressure in this room that you simply cannot escape. When you are surrounded by dozens of people who are silently, stubbornly refusing to give up on their goals, it changes something inside you. You look up, feeling tired and defeated, catch someone else rubbing their tired eyes over a heavy textbook, and you feel less alone.</p><p>You put your phone away. You take a deep breath. And you give that impossible question, that frustrating bug, or that dense chapter one more try.</p><p>Finding Pride in the Chaos</p><p>I am slowly, stubbornly getting attached to this place.</p><p>It’s a room where I have faced maximum confusion, heavy frustration, and bone-deep exhaustion. But it’s also the place where, every now and then, I feel a sudden, quiet wave of pride for understanding something small. A piece of logic clicks. A concept finally makes sense.</p><p>We might walk in here running on caffeine and pressure, hiding from our own distractions under the judgment of imaginary security cameras. But we leave a little stronger, a little wiser, and a lot more connected to the grind.</p><p>Here is to surviving another late night under the library lights—may your code compile, your focus hold, and your Instagram reels stay hidden.</p><p>What does your current daily routine look like—are you also pulling late nights somewhere that feels like a second home?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92d31fb3dc7d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Basics of Backened !]]></title>
            <link>https://tanyasanskriti08.medium.com/basics-of-backened-8e74c9e4a0a7?source=rss-5ba65246b5d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/8e74c9e4a0a7</guid>
            <category><![CDATA[https]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[middleware]]></category>
            <category><![CDATA[expressjs]]></category>
            <category><![CDATA[backend-development]]></category>
            <dc:creator><![CDATA[TanyaGupta]]></dc:creator>
            <pubDate>Sat, 10 Oct 2026 12:45:14 GMT</pubDate>
            <atom:updated>2026-10-10T12:45:14.710Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oN1sY9RhIpLnif3X" /><figcaption>Photo by <a href="https://unsplash.com/@arifriyanto?utm_source=medium&amp;utm_medium=referral">Arif Riyanto</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>What I have studied in backend development so far:</p><p>Backend is the logic behind an application. The client initiates a request, and the server receives it, processes it, and sends a response. HTTP is the protocol used for communication between the client and server.</p><p>JSON is a lightweight data format commonly used to exchange data. Its syntax is similar to JavaScript objects, but JSON is a text format, whereas a JavaScript object is an object used within JavaScript.</p><p>I also learned the difference between Node.js and Express.js. Node.js is a runtime environment for running JavaScript outside the browser. It does not provide a built-in routing system like Express. Express.js is a web framework for Node.js, depends on the Node.js environment, and provides routing and middleware support.</p><p>A route defines how an application responds to a particular URL path and HTTP method. Routing connects an incoming request to the correct handler.</p><p>Middleware is a function that runs during the request–response cycle. It can access the request and response objects, perform operations, and pass control to the next middleware using next().</p><p>There are five types of middleware:</p><p>Application-level middleware: It is attached to the application using app.use() or methods such as app.get(). It can be used for authentication, logging, and other tasks. It applies to the requests that match its configuration. app.use() can handle different HTTP methods, while app.get() handles only GET requests.</p><p>2.</p><p>Router-level middleware: It works within an Express router and helps organise groups of routes. It is attached using router.use() or methods such as router.get() and applies to matching requests handled by that router.</p><p>3.</p><p>Built-in middleware: These middleware functions are provided by Express, such as express.json(), which parses incoming JSON request bodies, and express.static(), which serves static files.</p><p>4.</p><p>Error-handling middleware: It handles errors and sends appropriate error responses. It uses four parameters: err, req, res, and next. It is usually defined after the other middleware and routes. It handles an error when one is passed to it; it does not repeatedly generate responses until the error is cleared.</p><p>5.</p><p>Third-party middleware: These packages can be installed through npm and used for tasks such as authentication, logging, and processing requests.</p><p>Then comes handling requests and responses. Express provides request and response objects that help the server understand incoming HTTP requests and send responses to the client.</p><p>Response handling determines how the server presents the output and what data it sends. Request handling involves understanding what the client wants, reading the information it sends, and matching the request to the appropriate route. A response can contain plain text, HTML, files, or other data. API responses commonly contain JSON data.</p><p>I also learned the difference between synchronous and asynchronous execution. Synchronous execution is blocking: if a task takes time, the current execution waits for it to finish before moving to the next task. Asynchronous operations allow execution to continue while waiting for an operation, such as reading a file, to complete.</p><p>And also have installed the node.js setup and tested commands such as npm — init,npm install express and also worked on file server.js…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8e74c9e4a0a7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning AI Beyond the Output: My Journey Through Fundamentals and Ethics]]></title>
            <link>https://tanyasanskriti08.medium.com/learning-ai-beyond-the-output-my-journey-through-fundamentals-and-ethics-16b771403be1?source=rss-5ba65246b5d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/16b771403be1</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[education]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-analysis]]></category>
            <dc:creator><![CDATA[TanyaGupta]]></dc:creator>
            <pubDate>Fri, 02 Oct 2026 15:28:22 GMT</pubDate>
            <atom:updated>2026-10-02T15:28:22.580Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4fJSgNKp7UFvQnW9" /><figcaption>Photo by <a href="https://unsplash.com/@markuswinkler?utm_source=medium&amp;utm_medium=referral">Markus Winkler</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><em>From solving machine learning questions to understanding the responsibility behind an AI system.</em></p><p>Recently, I have been spending more time learning the foundations of artificial intelligence and the ethical questions that come with it.</p><p>My learning has included clustering, random forests, entropy, information gain, cross-validation, and correlation. Alongside these technical topics, I have been exploring bias, accountability, privacy, and transparency.</p><p>Working through them together is helping me develop a broader understanding of AI. I want to understand how a model reaches an answer, how we evaluate that answer, and what its consequences might be for the person receiving it.</p><p>I am still learning. This blog is a reflection on what I have covered so far and the questions I am beginning to ask.</p><h3>Making Sense of Algorithms Through Questions</h3><p>One of the topics I studied was <strong>K-medoids clustering</strong>, where each cluster is represented by an actual data point called a medoid. I also explored <strong>complete linkage</strong> in hierarchical clustering, which measures the distance between two clusters using the farthest pair of points across them.</p><p>Solving questions helped me move beyond remembering the names. I had to follow the distances, understand the grouping process, and work through how a particular rule affects the result.</p><p>I also practised a classification question involving a diamond surrounded by squares and circles. The task was to determine which class the diamond should belong to by examining its neighbours.</p><p>That exercise helped me understand the idea behind <strong>K-nearest neighbours</strong>: a point can be classified using the labels of nearby points, with the chosen value of <em>K</em> determining how many neighbours are considered. In a simple voting approach, the most common class among those neighbours determines the prediction.</p><p>Seeing the problem visually made the concept easier to follow. Changing <em>K</em> could change the neighbourhood being considered, which made me pay closer attention to the reasoning behind the answer.</p><h3>Understanding Entropy and Information Gain</h3><p>I also worked through questions on <strong>entropy and information gain</strong>.</p><p>Entropy helped me understand how we describe uncertainty or class mixture in a dataset. Information gain then helped me understand how much that uncertainty decreases after a split.</p><p>Calculating these values made the connection to decision trees clearer. A split has a purpose: it should help separate the data in a useful way.</p><p>This is something I am noticing across my learning. A definition may feel familiar when I read it, but solving a question reveals whether I can actually use it.</p><p>Writing out the steps helps me recognise where my understanding is strong and where I need to revisit the concept.</p><h3>Separating Bagging, Boosting, Bootstrapping, and Aggregating</h3><p>These terms initially felt closely connected, so I spent time understanding their individual roles.</p><p><strong>Bootstrapping</strong> means creating samples from a dataset by sampling with replacement. <strong>Aggregating</strong> means combining multiple predictions, such as through averaging or voting. <strong>Bagging</strong>, short for bootstrap aggregating, brings these ideas together by training models on bootstrap samples and combining their outputs.</p><p><strong>Boosting</strong> usually builds models sequentially, with later models addressing weaknesses in the combined model developed so far. Studying these distinctions helped me understand ensemble learning more clearly.</p><p>I also learned about <strong>random forests</strong>, which combine multiple decision trees and introduce randomness through data sampling and the selection of features considered at each split.</p><p>What interested me was the idea that several models can contribute to one prediction. Understanding how those models are created and combined gave me a better sense of why ensemble methods work.</p><h3>Learning How to Evaluate a Model</h3><p>Another topic I practised was <strong>K-fold cross-validation</strong>.</p><p>The dataset is divided into <em>K</em> folds. In each round, one fold is used for validation and the remaining <em>K − 1</em> folds are used for training. This continues until every fold has served as the validation fold.</p><p>For example, with five approximately equal folds, each round uses roughly 80% of the data for training and 20% for validation. The results across the rounds provide a broader view of performance. A separate final test set can still be kept aside for evaluation after model selection.</p><p>Solving these questions helped me understand what <em>K</em> actually controls. It determines the number of folds and, consequently, the training and validation proportions in each round.</p><p>I also studied the <strong>Pearson correlation coefficient</strong>, which describes the direction and strength of a linear relationship between two variables.</p><p>Together, these topics are encouraging me to look more carefully at data and evaluation. A performance score becomes more meaningful when I understand how it was obtained.</p><h3>Exploring the Bigger Picture of AI</h3><p>Alongside the algorithms, I learned about three categories discussed in AI: <strong>Artificial Narrow Intelligence (ANI), Artificial General Intelligence (AGI), and Artificial Superintelligence (ASI)</strong>.</p><p>These helped me distinguish task-specific capabilities from the broader ideas of general intelligence and intelligence beyond human capabilities.</p><p>I also took an introductory look at <strong>deep learning and neural networks</strong>. At this stage, my focus is on understanding the basic structure: how layers process information, how weights are adjusted during learning, and how deep learning fits within machine learning.</p><p>There is still much more for me to explore. Having an overview gives me a starting point for connecting these topics as I continue.</p><h3>Looking Back at AI’s History</h3><p>Learning about AI’s evolution added another perspective.</p><p>I read about Alan Turing’s 1950 paper, <em>Computing Machinery and Intelligence</em>, in which he introduced the imitation game that became associated with the Turing test.</p><p>I also learned about the <strong>1956 Dartmouth workshop</strong>, a foundational event in AI research. The term “artificial intelligence” appeared in the 1955 proposal for that workshop.</p><p>My study also covered the first and second <strong>AI winters</strong>, including the setbacks and reduced confidence that formed part of the field’s development.</p><p>This history made me more curious about how expectations around technology develop. It reminded me to look beyond excitement and ask what a system can demonstrate in practice.</p><h3>Why AI Ethics Is Becoming Part of My Learning</h3><p>The ethical side of AI has introduced questions that stay with me beyond a solved exercise.</p><p><strong>Bias</strong> makes me think about who is represented in the data and who might receive unfair outcomes.</p><p><strong>Accountability</strong> raises the question of who takes responsibility when a system causes harm or makes an incorrect decision.</p><p><strong>Privacy</strong> makes me consider how personal information is collected, used, and protected.</p><p><strong>Transparency</strong> encourages me to ask whether people can understand how a system was developed, what it does, and where its limitations lie. These concerns are central to discussions of trustworthy AI.</p><p>A useful example for me is an AI system that helps screen job applications. Evaluating its overall performance would be one part of understanding it. I would also want to know whether certain applicants are disadvantaged, whether their information is protected, and whether there is a way to question a decision.</p><p>Thinking through examples like this helps me connect ethics with the technical choices involved in building a system.</p><h3>What I Want to Carry Forward</h3><p>My goal is to keep building an understanding that I can explain and apply.</p><p>That means solving questions, revisiting concepts, checking my reasoning, and being honest about what I have only explored at an introductory level.</p><p>Learning AI fundamentals is helping me understand the mechanisms behind a model. Learning AI ethics is helping me think about the people affected by those mechanisms.</p><p>As I continue, I want both perspectives to influence the way I approach projects. I want to ask thoughtful questions about the data, the evaluation, and the responsibility that comes with using the result.</p><p>For now, that learning happens one concept and one worked question at a time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=16b771403be1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“From 20K Rows to 226 Columns: My First Data Sanity Check”]]></title>
            <link>https://tanyasanskriti08.medium.com/from-20k-rows-to-226-columns-my-first-data-sanity-check-4207d0c06c73?source=rss-5ba65246b5d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/4207d0c06c73</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-analysis]]></category>
            <dc:creator><![CDATA[TanyaGupta]]></dc:creator>
            <pubDate>Mon, 14 Sep 2026 15:02:54 GMT</pubDate>
            <atom:updated>2026-09-14T15:02:54.102Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4bjveFMdQVudnYmpGvyQUA.png" /></figure><h3>LabelForge: My Progress So Far</h3><p>I have recently started working on <strong>LabelForge</strong>, a multi-label classification project. Before moving towards model training, I began by understanding the basic concepts and checking whether the given dataset had the correct structure.</p><p>This initial stage taught me that a machine-learning project does not begin directly with selecting or training a model. It starts with understanding the problem and checking whether the data is organised correctly.</p><h3>Understanding Classification</h3><p>The first concept I studied was classification. There are three main types: binary classification, multiclass classification and multi-label classification.</p><p>In <strong>binary classification</strong>, one sample receives one of two possible outputs. A common example is email classification, where an email may be classified as spam or not spam.</p><p>In <strong>multiclass classification</strong>, more than two classes are available, but each sample is assigned only one of them. For example, an image may be classified as a cat, dog or horse, but it receives only one final class.</p><p>In <strong>multi-label classification</strong>, one sample can have multiple labels at the same time. For example, a movie can belong to comedy, romance and drama together. Here, the genres are labels. Information such as the movie’s duration or rating could be treated as features.</p><p>LabelForge is a multi-label classification project because every sample can have more than one active label.</p><h3>Beginning with a Data Sanity Check</h3><p>After understanding the problem type, I performed a <strong>data sanity check</strong>.</p><p>A data sanity check means verifying whether the dataset has the expected dimensions, columns, values and format. It helps confirm that the dataset has loaded correctly before any analysis or modelling begins.</p><p>For this process, I used Google Colab and worked with three basic Python libraries:</p><ul><li><strong>Pandas</strong> for loading, organising and analysing tabular data</li><li><strong>NumPy</strong> for numerical calculations</li><li><strong>Matplotlib</strong> for creating graphs</li></ul><p>I used Pandas to load the training CSV file into a DataFrame. A DataFrame stores data in a table containing rows and columns.</p><h3>Understanding head() and shape</h3><p>After loading the file, I used head() to display the first five rows of the dataset. This allowed me to look at the sample ID, feature columns, label columns and the values stored inside them.</p><p>I then used shape to check the dataset’s dimensions. It returns the total number of rows and columns.</p><p>The LabelForge training dataset contains:</p><ul><li><strong>20,000 rows</strong></li><li><strong>226 columns</strong></li></ul><p>These 226 columns include:</p><ul><li>One sample ID column</li><li>200 feature columns</li><li>25 label columns</li></ul><p>Each row represents one sample. The feature columns contain numerical inputs, while the label columns contain the outputs that a model will later try to predict. The sample ID identifies each individual row.</p><p>I also inspected the column headings to separate the sample ID, features and labels correctly.</p><h3>Understanding Data Types</h3><p>The feature columns use the float64 data type because they contain decimal values. The label columns use int64 because their values are whole numbers, mainly 0 and 1.</p><p>In this dataset:</p><ul><li>0 means that a label is absent.</li><li>1 means that a label is present.</li></ul><p>The number 64 refers to the number of bits used to store each value. Checking these data types helped confirm that the features and labels were stored in a suitable numerical format.</p><h3>Learning About Missing Values</h3><p>While inspecting the dataset, I also learned about missing values.</p><p>Pandas represents a missing value as NaN. A missing value means that the cell exists, but the information that should be stored inside it is unavailable.</p><p>Data may be missing because it was not available at the time of collection, because of a system error, or because information did not match when different files were combined.</p><p>I learned that:</p><ul><li>isna() detects missing values.</li><li>dropna() temporarily ignores missing values.</li><li>unique() displays each different value only once.</li><li>The first sum() counts missing values column-wise.</li><li>The second sum() adds those counts to produce the total.</li></ul><p>After running these checks, I found <strong>374,029 missing feature values</strong>. However, there were <strong>no missing values in the label columns</strong>.</p><p>I have only identified and counted the missing values at this stage. I have not removed or replaced them yet.</p><h3>Checking Duplicate Rows</h3><p>Another part of my data sanity check was identifying duplicate rows.</p><p>Duplicate rows are repeated copies of the same sample. After checking the training dataset, I found that it contains <strong>no duplicate rows</strong>.</p><p>This confirmed that the samples had not been accidentally repeated in the file.</p><h3>Structural and Statistical Patterns</h3><p>During this process, I understood that datasets contain two broad types of patterns: structural and statistical.</p><p><strong>Structural patterns</strong> describe how the dataset is organised. They include:</p><ul><li>Number of rows and columns</li><li>Column names</li><li>Data types</li><li>Missing values</li><li>Duplicate rows</li><li>Incorrect or irregular format</li></ul><p><strong>Statistical patterns</strong> describe relationships within the actual values. They help us understand how different parts of the data may be connected.</p><p>My work so far has focused mainly on structural patterns. Statistical pattern analysis will be the next stage of the project.</p><h3>Overfitting and Underfitting</h3><p>I also studied two important machine-learning problems: overfitting and underfitting.</p><p><strong>Overfitting</strong> happens when a model learns the training data too specifically. It performs well on the training data but poorly on new data.</p><p><strong>Underfitting</strong> happens when a model is too simple to learn the required patterns. As a result, it performs poorly on both training data and new data.</p><p>Understanding these ideas will become useful when I begin training and comparing models later in the project.</p><h3>My Progress So Far</h3><p>So far, I have completed the basic coding and structural inspection of the LabelForge training dataset on Google Colab.</p><p>I confirmed that:</p><ul><li>The dataset has 20,000 rows and 226 columns.</li><li>It contains one sample ID, 200 features and 25 labels.</li><li>Feature values are stored as float64.</li><li>Label values are stored as int64.</li><li>Labels use binary values of 0 and 1.</li><li>There are 374,029 missing feature values.</li><li>There are no missing label values.</li><li>There are no duplicate rows.</li></ul><p>This first stage helped me understand that checking the data is an important part of machine learning. Before asking a model to learn from a dataset, I first needed to understand how that dataset was structured and whether it contained any basic issues.</p><p>The next stage of LabelForge will involve moving from structural checks towards understanding the statistical patterns present in the data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4207d0c06c73" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MCP Finally Made Sense When I Stopped Seeing It as “Just Another AI Term”]]></title>
            <link>https://tanyasanskriti08.medium.com/mcp-finally-made-sense-when-i-stopped-seeing-it-as-just-another-ai-term-8280cd6188df?source=rss-5ba65246b5d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/8280cd6188df</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <dc:creator><![CDATA[TanyaGupta]]></dc:creator>
            <pubDate>Wed, 09 Sep 2026 05:25:01 GMT</pubDate>
            <atom:updated>2026-09-09T05:25:01.602Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hb7B9T-OixsKEjd-VgPmdA.jpeg" /></figure><p>A beginner-friendly explanation of how hosts, clients, servers, tools, resources and prompts work together in an AI system.<br>For a while, MCP felt like one more abbreviation added to the already long dictionary of artificial intelligence.<br>LLMs, RAG, agents, APIs—and now MCP.<br>Knowing a definition and understanding a system are two different things. MCP started making sense to me when I stopped seeing it as a complicated protocol and imagined it as a team working together.<br>MCP stands for Model Context Protocol. In simple words, it provides a standard way for an AI application to connect with external information and actions.<br>Think about a normal AI chatbot. It can answer questions using what it already knows. But what if you ask it to read your latest email, check your calendar, find a free meeting room and invite your team?<br>The AI cannot complete those tasks using language ability alone. It needs access to other systems. More importantly, it needs a clear and controlled way to communicate with them.<br>That is where MCP enters the picture.<br>A Simple Office Example<br>Imagine an AI assistant called Ava working inside an office application.<br>A user says:<br>“Please schedule a team meeting for next week and send invitations.”<br>This sounds like one request, but it contains several smaller tasks. Ava may need to:<br>Check everyone’s calendar.<br>Find a common free time.<br>Search for an available meeting room.<br>Reserve that room.<br>Send an email invitation.<br>Confirm the final details to the user.<br>The AI understands the sentence, but it cannot magically enter a calendar or reserve a room. It needs specialised services to perform each action. MCP creates a common structure through which the AI application can discover and use those services.<br>The Host: Where the User Meets the AI<br>The host is the main application in which the AI assistant runs. It could be a desktop application, an AI coding tool or another interface where the user gives instructions.<br>You can think of the host as an office manager. The manager receives your request and coordinates the work, but does not personally perform every specialised task.<br>The MCP Client: The Communication Bridge<br>Inside the host is an MCP client. Its job is to communicate with an MCP server.<br>Imagine the client as a messenger. The host says, “We need to check the calendar,” and the client carries that request to the correct server. When the server responds, the client brings the result back.<br>A host can use multiple clients to communicate with different servers. This keeps the system clean because the main AI application does not need to contain the unique technical logic of every outside service.<br>The MCP Server: The Specialist<br>An MCP server connects the AI application to a particular source of data or capability.<br>In our office example, one server may specialise in calendars, another in room bookings and another in email.<br>An MCP server generally exposes three important things:<br>1. Resources: Information to Read<br>Resources are pieces of information that the AI can access.<br>A resource might be a file, email, document or database entry.<br>The easiest way to remember it is:<br>Resources are usually things the AI reads.<br>2. Tools: Actions to Perform<br>Tools allow the AI to do something.<br>A tool could schedule a meeting, send an email, reserve a room or update a record.<br>So:<br>Resources provide knowledge; tools provide action.<br>3. Prompts: Ready-Made Instructions<br>Prompts are reusable instructions provided by a server.<br>For example, a server might offer a prompt called “Summarise this email.” The application can reuse it instead of building the instruction from scratch every time.<br>Discovery: How the AI Knows What Is Available<br>One concept I found especially important was discovery.<br>When a client connects to an MCP server, the server can advertise its available resources, tools and prompts. The AI application can then understand what it is allowed to use.<br>It is like opening a restaurant menu: you first see the available options and then choose what fits your need.<br>Through discovery, the AI might learn:<br>“I can read calendar events.”<br>“I can search for an available room.”<br>“I can send an email invitation.”<br>Invocation: When a Capability Is Actually Used<br>Discovering a tool and using it are not the same thing.<br>Invocation happens when the AI selects an available capability and calls it. After learning that a calendar tool exists, the AI invokes it with details such as the required date, time and participants.<br>In short:<br>Discovery means finding what is available. Invocation means using it.<br>Elicitation: When the AI Needs More Information<br>Sometimes a request is incomplete.<br>Suppose the user says, “Book a meeting room,” but does not mention the date or number of attendees. The system should not blindly guess. It may need to ask the user for the missing details.<br>This process is called elicitation.<br>Elicitation lets the system pause and collect what it needs to continue correctly. It is a small concept, but it makes AI interactions more reliable.<br>Why This Architecture Matters<br>Security<br>An MCP server can limit available information and actions. An AI may view meeting times but not confidential employee records. Access remains controlled instead of giving the AI unlimited reach.<br>Flexibility and Scalability<br>If a company adds a service, developers can connect another MCP server rather than rewriting the entire assistant.<br>Clearer Development<br>The host manages the experience, the client handles communication and the server provides specialised capabilities. Clear responsibilities make the system easier to update.<br>What Finally Clicked for Me<br>My biggest takeaway was that MCP is not the intelligence of the AI itself. It is the structured connection that helps that intelligence interact with useful systems. An LLM may understand that a meeting needs to be scheduled; MCP helps turn that understanding into an organised sequence of actions.<br>The simplest analogy I found is this:<br>The user gives the goal.<br>The host manages the overall experience.<br>The client carries requests and responses.<br>The server provides specialised capabilities.<br>Resources offer information.<br>Tools perform actions.<br>Prompts provide reusable instructions.<br>Discovery finds available capabilities.<br>Invocation uses a capability.<br>Elicitation asks for missing details.<br>Once I mapped these pieces by hand, MCP stopped looking like a collection of unfamiliar terms. It began to look like a well-organised team.<br>And perhaps that is the easiest way to understand it: MCP gives AI applications a common language for working with the world beyond the model.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8280cd6188df" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Arcanova May Be the Application I Built, but the Version of Me That Came Out of Building It Might…]]></title>
            <link>https://tanyasanskriti08.medium.com/arcanova-may-be-the-application-i-built-but-the-version-of-me-that-came-out-of-building-it-might-b73335e1f1d5?source=rss-5ba65246b5d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/b73335e1f1d5</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[TanyaGupta]]></dc:creator>
            <pubDate>Fri, 04 Sep 2026 10:18:55 GMT</pubDate>
            <atom:updated>2026-09-04T14:07:06.540Z</atom:updated>
            <content:encoded><![CDATA[<h3>Arcanova May Be the Application I Built, but the Version of Me That Came Out of Building It Might Be the More Important Project…</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DSm-dg7t8Yp3i66dQsNtSg.png" /></figure><p>Three months of confusion, broken prompts, incomplete stories, model testing, TTS experiments, “Module not found,” 3 AM debugging sessions, and finally turning a vague idea into a working AI application.</p><p>There are some projects you complete, upload somewhere, mention in your portfolio, and eventually move on from.</p><p>And then there are projects that become attached to a particular phase of your life.</p><p>For me, Arcanova became one of those projects.</p><p>When I look back at the last few months, I don’t really remember July, August, and the first few days of September as three separate months anymore.</p><p>I remember Google Colab tabs.</p><p>I remember running the same prompt again because the previous story stopped halfway.</p><p>I remember listening to generated voices repeatedly because something about them still felt too artificial.</p><p>I remember dependencies, installations, integrations, errors, localhost, Streamlit, and one message that became almost too familiar:</p><p>ModuleNotFoundError.</p><p>And, more than anything, I remember looking at the clock and realising it was already 3 AM.</p><p>Again.</p><p>Arcanova took much longer than I originally imagined.</p><p>But looking back now, I think that was exactly what made the project valuable.</p><p>July: I Had an Idea, Not a Plan</p><p>When I started in July, I knew one thing clearly:</p><p>I wanted to build something around AI storytelling and narration.</p><p>That was almost the entire plan.</p><p>I didn’t have the complete architecture figured out.</p><p>I didn’t know which LLM I was going to use.</p><p>I didn’t know which text-to-speech model would work.</p><p>I didn’t know what the interface would eventually look like.</p><p>And I definitely didn’t know how many times I would change my approach before getting there.</p><p>At that stage, the idea in my head sounded simple:</p><p>User gives an idea → AI creates a story → AI narrates it.</p><p>Three steps.</p><p>How difficult could that be?</p><p>Very difficult, apparently.</p><p>The first thing Arcanova taught me was that a clean flowchart can hide a very messy reality.</p><p>My First Mistake: Starting With API Integration</p><p>I started working on Google Colab.</p><p>And instead of first spending enough time testing the models individually, I jumped directly into API integration.</p><p>At that moment, it felt like progress.</p><p>I was connecting things.</p><p>I was receiving responses.</p><p>There was code running.</p><p>Something was happening.</p><p>But eventually I realised that I was building integrations around models I hadn’t properly understood yet.</p><p>That became my first major mistake.</p><p>I knew what an API did.</p><p>But I hadn’t asked enough questions about the thing behind that API.</p><p>Could this model actually generate the kind of story I wanted?</p><p>Would it follow the required length?</p><p>Would it maintain a narrative from beginning to end?</p><p>Would the results remain consistent?</p><p>Would it understand different genres?</p><p>Would it repeat itself?</p><p>Would it follow detailed prompts reliably?</p><p>I had started building the pipeline before answering the questions the pipeline depended on.</p><p>So I stopped.</p><p>I went backwards.</p><p>And surprisingly, going backwards became the moment when I actually started moving forward.</p><p>What I understood</p><p>- Integration is not the first step just because it feels productive.<br>- A successful API call does not mean a model is suitable for the product.<br>- Models need to be evaluated before they are integrated.<br>- “It generated an output” and “it generated the right output” are completely different things.</p><p>That small realisation changed the direction of the entire project.</p><p>Model After Model, Prompt After Prompt</p><p>Once I stopped focusing only on integration, I started testing LLMs properly.</p><p>And this phase tested my patience more than I expected.</p><p>Story generation sounds simple until you actually need the model to behave consistently.</p><p>Some models generated much fewer words than I asked for.</p><p>I would request a detailed narrative and receive something that felt more like a summary.</p><p>Some models started strongly but suddenly ended the story halfway.</p><p>Some ignored parts of the prompt.</p><p>Sometimes I specified the genre, tone, structure, and word count clearly, but the final output still looked nothing like what I had imagined.</p><p>Other times, the model generated a story correctly once, and on the next run, the quality changed completely.</p><p>Then came another problem.</p><p>Repetition.</p><p>I would ask for a completely new story, wait for the result, and realise that the structure somehow felt almost identical to the previous one.</p><p>Different names.</p><p>Different setting.</p><p>Different sentences.</p><p>But underneath everything, it felt like the same story wearing a different outfit.</p><p>That was frustrating.</p><p>So I started changing prompts.</p><p>Then changing them again.</p><p>I experimented with instructions, constraints, descriptions, formats, genres, and different ways of telling the model exactly what I expected.</p><p>Sometimes one tiny change improved everything.</p><p>Sometimes a very detailed prompt somehow made the output worse.</p><p>And sometimes I would spend a long time changing the prompt only to discover that the problem was not really the prompt at all.</p><p>Problems I kept running into</p><p>- Stories shorter than the requested length<br>- Incomplete narratives<br>- Repetitive plots<br>- Similar outputs across different requests<br>- Models ignoring parts of the prompt<br>- Narratives occasionally failing to generate<br>- Good results on one run and poor results on another<br>- Difficulty maintaining tone throughout the story</p><p>This was the stage where I stopped thinking of model testing as simply “trying different AI models.”</p><p>I started thinking about consistency.</p><p>Reliability.</p><p>Instruction following.</p><p>Output quality.</p><p>And most importantly, whether I could actually build something around the model.</p><p>Why Qwen Became Part of Arcanova</p><p>After testing and experimenting with different LLMs, I eventually moved forward with Qwen for narrative generation.</p><p>By that point, my way of evaluating a model had already changed.</p><p>Earlier, I might have been impressed simply because a model could generate a good-looking story.</p><p>Now I wanted to know:</p><p>Can it do this repeatedly?</p><p>Can it understand my prompt?</p><p>Can it produce enough detail?</p><p>Can it maintain the story?</p><p>Can I actually build a pipeline around it?</p><p>Choosing Qwen was not the end of the testing.</p><p>But it gave Arcanova something stable enough to build upon.</p><p>And for a short moment, I thought:</p><p>Okay.</p><p>The difficult part is probably over.</p><p>Then I started working on text-to-speech.</p><p>TTS Taught Me That “Correct” Can Still Feel Wrong</p><p>The next goal was simple on paper.</p><p>Take the generated narrative and convert it into speech.</p><p>Initially, I thought this stage would be easier.</p><p>The model has text.</p><p>The TTS system reads it.</p><p>Done.</p><p>But when I actually started listening to the generated narration, I realised something.</p><p>The voice was understandable.</p><p>The words were correct.</p><p>Technically, it worked.</p><p>But something was missing.</p><p>It sounded like an AI reading a story.</p><p>I wanted it to feel like someone was actually telling one.</p><p>That distinction became important to me.</p><p>A storyteller doesn’t just pronounce words correctly.</p><p>There is rhythm.</p><p>There are pauses.</p><p>There is warmth.</p><p>There is expression.</p><p>There are tiny changes in the voice that make you want to continue listening.</p><p>And once I realised that, I couldn’t simply ignore it.</p><p>So the testing started again.</p><p>Listening Became Part of Development</p><p>With text generation, you can scan an output quickly and notice problems.</p><p>TTS is different.</p><p>You have to listen.</p><p>Then listen again.</p><p>Then compare.</p><p>Then realise that one sentence sounds natural but the next sounds completely flat.</p><p>Sometimes pronunciation was clear but emotion was missing.</p><p>Sometimes pacing felt unnatural.</p><p>Sometimes the narration felt too mechanical.</p><p>Sometimes a sentence that looked perfectly normal on the screen sounded strange when spoken aloud.</p><p>I tested different TTS possibilities and slowly learned that evaluating audio requires a completely different kind of attention.</p><p>Eventually, Kokoro became part of Arcanova’s narration pipeline.</p><p>And even then, I knew it wasn’t perfect.</p><p>I still think the narration can become more human.</p><p>It can become more expressive.</p><p>It can handle emotions better.</p><p>It can improve in pacing.</p><p>But one lesson Arcanova kept teaching me was this:</p><p>You don’t need perfection before you are allowed to move forward.</p><p>What TTS taught me</p><p>- Clear audio does not automatically mean good narration.<br>- Human-like storytelling depends heavily on pacing and expression.<br>- Evaluating audio is very different from evaluating text.<br>- The technically “best” output is not always the one that feels best to a user.<br>- AI systems should be judged from the user experience, not only from whether the code runs.</p><p>That last point stayed with me.</p><p>A lot of things can work technically and still not feel right.</p><p>From Google Colab to Localhost</p><p>After spending so much time inside Google Colab, I reached the point where Arcanova needed to become more than experiments inside notebook cells.</p><p>I wanted to make it feel like actual software.</p><p>So I shifted the project to my local environment.</p><p>And suddenly, an entirely new category of problems appeared.</p><p>Dependencies.</p><p>Different environments.</p><p>Packages.</p><p>Versions.</p><p>File paths.</p><p>Installations.</p><p>Things that worked in Colab but somehow refused to work locally.</p><p>Things I thought I had installed but Python apparently had a completely different opinion about.</p><p>And then there was the error that deserves its own sentence:</p><p>Module not found.</p><p>I lost count of how many times I saw some version of that problem.</p><p>At first, errors like these felt annoying because they seemed unrelated to the “interesting” AI part of the project.</p><p>Eventually, I realised that they were part of building the project too.</p><p>You can have the perfect model and still have no application if the surrounding system does not work.</p><p>What this stage taught me</p><p>- Environment setup is part of software engineering.<br>- Dependency management matters.<br>- A model working in a notebook does not guarantee that the complete system will work elsewhere.<br>- Debugging often means understanding the environment, not just rewriting code.<br>- Tiny technical issues can stop an entire AI pipeline.</p><p>That phase probably taught me more patience than anything else.</p><p>When Streamlit Made Arcanova Feel Real</p><p>Eventually, I started bringing everything together using Streamlit.</p><p>That was one of the most satisfying parts of the entire project.</p><p>Before Streamlit, Arcanova existed in pieces.</p><p>There was the story-generation part.</p><p>There was Qwen.</p><p>There was the narration pipeline.</p><p>There was Kokoro.</p><p>There were prompts.</p><p>Outputs.</p><p>Files.</p><p>Tests.</p><p>Errors.</p><p>It existed technically.</p><p>But it didn’t yet feel like a product.</p><p>Then the interface started coming together.</p><p>Suddenly, I could interact with the system differently.</p><p>The user could give an input.</p><p>The narrative could be generated.</p><p>The narration could follow.</p><p>The separate components started behaving like parts of one application.</p><p>And I remember thinking:</p><p>This is finally starting to look like the thing I imagined.</p><p>That feeling is difficult to explain if you have never spent weeks seeing your project only as disconnected pieces.</p><p>Watching those pieces finally become one working flow felt different.</p><p>Google Colab had become localhost.</p><p>Localhost had become an interface.</p><p>Experiments had become software.</p><p>And Arcanova finally felt real.</p><p>Then Came the 3 AM Phase</p><p>This is probably the part of the project I will remember the longest.</p><p>There were many nights when I thought I was going to work for “just another hour.”</p><p>Then I would notice something.</p><p>A story felt repetitive.</p><p>A prompt could be better.</p><p>The narration sounded slightly off.</p><p>An integration behaved differently.</p><p>The interface needed a change.</p><p>So I would tell myself:</p><p>One more prompt.</p><p>One more test.</p><p>One more fix.</p><p>One more run.</p><p>And then I would look at the clock.</p><p>2:30 AM.</p><p>Sometimes 3 AM.</p><p>The strange thing is that some nights, the application was already working.</p><p>There was no major bug.</p><p>Nothing was completely broken.</p><p>I just wasn’t satisfied.</p><p>I would sit there thinking:</p><p>This can be better.</p><p>That mindset helped me improve the project.</p><p>But it also taught me something I didn’t expect.</p><p>At some point, you have to understand the difference between improving something and refusing to finish it.</p><p>The Hardest Lesson: Complete Does Not Mean Perfect</p><p>This was probably the most personal lesson Arcanova gave me.</p><p>I kept moving the finish line.</p><p>First, I thought:</p><p>I’ll finish when the story generation works.</p><p>Then it worked.</p><p>So I thought:</p><p>I’ll finish when the narration works.</p><p>Then it worked.</p><p>Then I wanted better prompts.</p><p>Then better consistency.</p><p>Then better TTS.</p><p>Then better integration.</p><p>Then better UI.</p><p>There was always another thing.</p><p>And there still is.</p><p>I can already list things I want to improve in Arcanova:</p><p>- More human-like narration<br>- Better emotional delivery<br>- More diversity in generated stories<br>- Stronger control over story length<br>- Improved prompt consistency<br>- Better handling of edge cases<br>- A more refined interface<br>- Better error handling<br>- More evaluation across different models</p><p>But if I waited until Arcanova had absolutely nothing left to improve, I would probably never finish it.</p><p>That was when I finally understood something very important:</p><p>Completed does not mean perfect.</p><p>Completed means you reached a version that works, learned from it, and created something real enough to improve later.</p><p>So, after July, August, and a little bit of September, I finally allowed myself to say:</p><p>Arcanova is complete.</p><p>For now.</p><p>What I Actually Learned</p><p>Technically, Arcanova gave me hands-on experience with things I had previously mostly studied separately.</p><p>I worked with:</p><p>- API integration<br>- Prompt experimentation<br>- LLM evaluation<br>- Qwen<br>- Text-to-speech testing<br>- Kokoro<br>- Streamlit<br>- Local environments<br>- Dependency management<br>- Debugging<br>- Model comparison<br>- Output evaluation<br>- Connecting multiple AI components into one pipeline</p><p>But I don’t think those are the biggest things I learned.</p><p>The biggest lessons were much less measurable.</p><p>I learned that understanding comes after struggling sometimes</p><p>There were many problems I couldn’t immediately solve.</p><p>Earlier, that would make me feel like maybe I simply didn’t understand enough.</p><p>Now I see those moments differently.</p><p>Not knowing is part of the process.</p><p>You research.</p><p>You test.</p><p>You break something.</p><p>You try again.</p><p>Eventually, something starts making sense.</p><p>I learned that successful output is not the same as a successful product</p><p>A model producing text does not automatically mean your storytelling system works.</p><p>A TTS model producing audio does not automatically mean the narration feels good.</p><p>An API returning a response does not automatically mean your integration is complete.</p><p>The user experience matters.</p><p>Consistency matters.</p><p>Reliability matters.</p><p>I learned how much patience AI engineering actually requires</p><p>AI projects look exciting from the outside.</p><p>And they are.</p><p>But there is also a huge amount of repetition.</p><p>Testing.</p><p>Comparing.</p><p>Debugging.</p><p>Waiting.</p><p>Listening.</p><p>Changing one parameter.</p><p>Running everything again.</p><p>And doing all of that even when you are not completely sure whether the next attempt will work.</p><p>And I learned to ship</p><p>Maybe this was the biggest one.</p><p>I could probably spend another month changing Arcanova.</p><p>But at some point, building also means deciding that the current version deserves to exist.</p><p>Not forever.</p><p>Not as the final version.</p><p>Just as the version you were capable of building today.</p><p>If I Could Go Back to July</p><p>If I could sit beside the version of myself who opened that first Google Colab notebook in July, I would probably tell her a few things.</p><p>Don’t rush into integrations.</p><p>Test the models properly.</p><p>Expect your prompts to fail.</p><p>Expect your first architecture to change.</p><p>Expect some outputs to make absolutely no sense.</p><p>Expect local environments to create problems you never had in Colab.</p><p>Expect to hear “Module not found” more often than you would like.</p><p>And maybe most importantly:</p><p>Don’t be scared when you don’t know what to do next.</p><p>You don’t need to understand the entire journey before you start.</p><p>Sometimes you only need to understand the next problem.</p><p>Then solve it.</p><p>Then move to the next one.</p><p>So, What Is Arcanova to Me Now?</p><p>Technically, Arcanova is an AI storytelling and narration application built around Qwen, Kokoro, and Streamlit.</p><p>But that description feels too small now.</p><p>Because when I look at Arcanova, I don’t just see the software.</p><p>I see July.</p><p>I see the first Colab notebook.</p><p>I see the API mistake.</p><p>I see incomplete stories.</p><p>I see prompts that refused to behave.</p><p>I see the excitement when Qwen finally started giving me something closer to what I wanted.</p><p>I see myself listening to TTS outputs again and again.</p><p>I see Kokoro becoming part of the pipeline.</p><p>I see localhost.</p><p>I see Streamlit.</p><p>I see errors.</p><p>I see 3 AM.</p><p>I see all those moments when I could have said, “I’ll do this later,” but stayed for one more run instead.</p><p>And that is probably why completing this project feels different.</p><p>Arcanova may not be perfect.</p><p>It may look completely different a few months from now.</p><p>I genuinely hope it does.</p><p>Because that would mean I kept improving it.</p><p>But the current version will always matter to me.</p><p>Because it represents the version of me who didn’t know exactly what she was building in July, but kept building anyway.</p><p>July.</p><p>August.</p><p>And a little bit of September.</p><p>A lot of confusion.</p><p>A lot of errors.</p><p>A lot of learning.</p><p>A few very late nights.</p><p>And finally, one working application.</p><p>Arcanova may be the application I built, but the version of me that came out of building it might be the more important project.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b73335e1f1d5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hallucination ≠ only an MCP problem.]]></title>
            <link>https://tanyasanskriti08.medium.com/hallucination-only-an-mcp-problem-a7a2540d2aa3?source=rss-5ba65246b5d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/a7a2540d2aa3</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[mcp-server]]></category>
            <dc:creator><![CDATA[TanyaGupta]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 16:45:39 GMT</pubDate>
            <atom:updated>2026-08-26T16:45:39.359Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wBKyMb4wvtgmjAHURlkZsw.png" /></figure><p>MCP fundamentals Patterns</p><p>1-context drift</p><p>2-tool inconsistency</p><p>3-silent failure propagation</p><p>MCP is standardized way for an AI model to interact with external tools and information.</p><p>context drift — AI slowly forgets what the actual task was b/c of long conversation / changing instructions / summaries of previous context. In this AI hasn’t completely forgotten everything. It has just lost precision about what matters.</p><p>Tool inconsistency — The same tool doesn’t behave the same way every time. Happens when different MCP servers implement similar tools differently, or might be tool returns incomplete information.</p><p>Silent failure propagation -&gt; Something broke but nobody notices so mistake travels forward.</p><p>Hallucinations &amp; MCP problem Context drift + unreliable tool + undetected failure = high chance of hallucination. Hallucination is a symptom. Context drift, tool inconsistency, silent failures are the causes.</p><p>Q — why prompting cannot fix agent failures?</p><p>Ans — sometimes prompting isn’t the issue it’s because how content and capabilities are delivered. Agentic AI imposes structural failures in tool guarantees and consistency.</p><p>Q — what is Agentic systems — An AI system that can autonomously pursue a goal by decision making, planning, adapting based on result just by receiving one prompt like “prepare me for interview”.</p><p>Problem connectivity not intelligence</p><p>As AI agents use more tools which needs its own connection and rules different tools may handle errors, missing info, permission differently. This is where agentic AI stop scaling.</p><p>MCP is like USB for AI agents. It gives AI standard way to connect with different tools and AI sources. Instead of building a custom connection for every tool, MCP provide common interface. MCP don’t tell AI what to think but how to connect / communicate and use external tools reliably.</p><p>MCP is port that connect AI agent to tools.</p><p>As AI agent become more powerful they start using many tools working through multiple steps and performing real actions. At that point rely on prompts and custom connection became unreliable.</p><p>MCP becomes useful when -&gt;</p><p>The agents uses many tools -&gt; tools may handle data differently. MCP gives them common way to communicate.</p><p>The agents works through many steps -&gt; MCP helps keep info and tool interactions consistent instead of letting context get confused.</p><p>The agent can take real actions -&gt; For things like refunds/permission/deployments the agent needs to clearly know whether an action succeeded failed or partially worked.</p><p>Multiple AI models use same tools -&gt; MCP lets diff agents/use same tool through one standard interface instead of custom connection.</p><p>* MCP becomes imp. when your AI system gets complicated enough that different tools/agent and actions needs to communicate in a predictable and standardized way.</p><p>For simple tasks/prototypes or one-link automations MCP may be unnecessary.</p><p>* use MCP when AI needs reliable, predictable and traceable connection to tools.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a7a2540d2aa3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Day 1 of my LeetCode journey.]]></title>
            <link>https://tanyasanskriti08.medium.com/day-1-of-my-leetcode-journey-5b689504aaeb?source=rss-5ba65246b5d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/5b689504aaeb</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data-structure-algorithm]]></category>
            <category><![CDATA[leetcode]]></category>
            <category><![CDATA[learning]]></category>
            <dc:creator><![CDATA[TanyaGupta]]></dc:creator>
            <pubDate>Mon, 10 Aug 2026 13:58:12 GMT</pubDate>
            <atom:updated>2026-08-10T13:58:12.839Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mxraOpQSBMBR_zIYhCwLHA.png" /></figure><p>Today I finally started practicing DSA seriously with Python.</p><p>I’ve decided to solve three LeetCode problems every day. The goal is not just to increase the number of problems on my profile, but to actually understand how I approach a problem, where I get stuck, and what I learn from each mistake.</p><p>For my first day, I solved three problems:</p><p>• Palindrome Number<br>• Roman to Integer<br>• Longest Common Prefix</p><p>The first one, Palindrome Number, looked quite straightforward. My approach was to convert the number into a string, reverse it, and compare it with the original.The logic was correct, but my first implementation definitely wasn’t.</p><p>I made some basic Python mistakes, like writing int reverse, using true and false instead of True and False, forgetting colons after if and else, and comparing a string with an integer.</p><p>These were small mistakes, but they reminded me that knowing what I want the program to do and actually writing it correctly are two different things.</p><p>Roman to Integer was a little different. Here, I had to think about the relationship between the current character and the next one instead of simply adding everything.</p><p>I used a dictionary to store the values of the Roman numerals and then compared the current value with the next value. If the current value was smaller, I subtracted it; otherwise, I added it.</p><p>For example, IV becomes -1 + 5 = 4.</p><p>The third problem, Longest Common Prefix, made me think more about loops and comparisons.</p><p>For a list such as [“flower”, “flow”, “flight”], I started looking at the strings character by character. I used one loop for the character position and another for comparing the different strings.</p><p>The idea was simple once I understood it: keep comparing characters at the same position and stop as soon as there is a mismatch.</p><p>What I liked about today’s practice is that I didn’t get everything right immediately. I had to stop, understand what was wrong, and try again.</p><p>That is probably what I want to get better at through this journey.</p><p>Not just solving a problem, but learning how to look at an unfamiliar problem and break it down into smaller parts.</p><p>My plan from here is simple: three problems a day, consistent practice, and understanding the approach before looking at a solution.</p><p>I know the first few problems are only the beginning. There will be plenty of problems ahead where the answer won’t come easily.</p><p>But that’s exactly why I’m starting.</p><p>Day 1 complete. Three problems down.</p><p>Let’s see how much better I can get by staying consistent.</p><p>#LeetCode #DSA #Python #ProblemSolving #CodingJourney #LearningInPublic</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5b689504aaeb" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>