<?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 Aaryan R Shelar on Medium]]></title>
        <description><![CDATA[Stories by Aaryan R Shelar on Medium]]></description>
        <link>https://medium.com/@aaryan.r.shelar5418?source=rss-a7cac932ef5b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*jF-KIy4K1-EpS9LW</url>
            <title>Stories by Aaryan R Shelar on Medium</title>
            <link>https://medium.com/@aaryan.r.shelar5418?source=rss-a7cac932ef5b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 13:09:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@aaryan.r.shelar5418/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[Something New Has Entered the AI Era: Loop Engineering]]></title>
            <link>https://medium.com/@aaryan.r.shelar5418/something-new-has-entered-the-ai-era-loop-engineering-dad3eee537db?source=rss-a7cac932ef5b------2</link>
            <guid isPermaLink="false">https://medium.com/p/dad3eee537db</guid>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[news]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Aaryan R Shelar]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 12:27:52 GMT</pubDate>
            <atom:updated>2026-11-03T12:30:29.435Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QCg88t8GSIlj-54ZqG6v-g.png" /></figure><p>A few days ago, I came across something that honestly made me stop for a second.</p><p><strong>Andrej Karpathy</strong>, one of the people who has been talking a lot about how software development is changing with AI, shared an idea around the future of working with AI that caught my attention.</p><p>The idea was basically this: we are moving away from the old way of constantly sitting in front of an AI, writing prompts, correcting the output, and asking again.</p><p>And people have started describing this shift with a pretty strong statement:</p><p><strong><em>“Prompting is dead.”</em></strong></p><p>Now, I don’t think prompting is literally dead.<br>We still need prompts. We still need to give AI context. We still need to explain what we want.<br>But I think something much more interesting is happening.</p><p><strong>The prompt is no longer the whole workflow.</strong></p><p>For the last few years, we have been obsessed with getting better at asking AI questions.</p><blockquote>“Write a better prompt.”<br>“Give more context.”<br>“Add examples.”<br>“Tell the model exactly what you want.”</blockquote><p>And yes, this works.</p><p>But now AI can do much more than just give us an answer.</p><blockquote>It can read your codebase.<br>It can modify files.<br>It can run commands.<br>It can run tests.<br>It can look at errors.<br>It can inspect the result.<br>And then it can try again.</blockquote><p><strong>That changes the whole game.</strong></p><h3>So What Is an AI Loop?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uGlKHILgD7iZs_mQ" /><figcaption>Photo by <a href="https://unsplash.com/@shenxq0825?utm_source=medium&amp;utm_medium=referral">Xiaoqian Shen</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>The simplest way I can explain an AI loop is:</p><p><strong><em>Give AI a goal → let it act → observe the result → verify it → adjust → try again.</em></strong></p><p>A normal AI interaction looks like:</p><blockquote><strong>Prompt → AI → Answer → Done</strong></blockquote><p>An AI loop looks more like:</p><blockquote><strong>Goal → Plan → Act → Observe → Verify → Adjust → Act again → Repeat</strong></blockquote><p>The important part is not just repeating. It is <strong>feedback</strong>.</p><p>The AI does something, sees what happened, checks whether the result is actually good, and then decides what to do next. And honestly, this is not a completely new idea.</p><p>Software developers have been working this way forever.</p><blockquote>You get an issue.<br>You understand it.<br>You write some code.<br>You run the test.<br>The test fails.<br>You read the error.<br>You change the code.<br>You run the test again.<br>Eventually, it works.</blockquote><p>AI loops are basically bringing this kind of feedback cycle into AI systems.</p><h4>Why Is This Interesting?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bs0UijbE5_WG9_p6" /><figcaption>Photo by <a href="https://unsplash.com/@farhat099?utm_source=medium&amp;utm_medium=referral">Farhat Altaf</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Let’s take a simple coding example.</p><p>Imagine you tell an AI coding agent: <strong>“Fix this bug.”</strong></p><p>In a basic workflow, the AI might look at the code, make a change and tell you: <strong>“Done.”</strong></p><p>Cool.</p><p>But is it actually fixed? You don’t know yet.</p><p>Now imagine the agent is allowed to work in a loop.</p><blockquote>It looks at the issue.<br>It finds the relevant code.<br>It makes a change.<br>It runs the test.<br>The test fails.<br>It reads the error.<br>It realizes the first approach was wrong.<br>It changes the implementation.<br>It runs the test again.<br>This time it passes.<br>Then it runs the related tests to make sure nothing else broke.</blockquote><p>Now it has actual evidence that the change works. That is a completely different workflow. The AI is not just <strong>answering your prompt</strong> anymore. It is <strong>working on the problem</strong>.</p><h4>The Most Important Part: Verification</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Fw8SxeFU0Br6LSx4" /><figcaption>Photo by <a href="https://unsplash.com/@franckinjapan?utm_source=medium&amp;utm_medium=referral">Franck</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>This is probably the part I find most important about loops.</p><blockquote>AI saying:<br><strong>“I think this is correct.”</strong></blockquote><p>doesn’t mean much.</p><blockquote>A test saying: <br><strong>127 tests passed</strong></blockquote><p>is much more useful.</p><blockquote>A type checker saying:<br><strong>0 errors</strong></blockquote><p>is useful.</p><p>A build passing is useful. A browser test passing is useful. The environment gives the AI feedback that is much closer to reality. This is why verification becomes such an important part of AI loops.</p><h4><strong>AI confidence is not verification.</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*septREDRVM301U60" /><figcaption>Photo by <a href="https://unsplash.com/@herrond?utm_source=medium&amp;utm_medium=referral">Daniel Herron</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Objective evidence is much stronger. And this is one reason coding is such a good area for AI loops.</p><p>There are already so many ways to verify things:</p><blockquote>pytest, ruff, mypy, type checkers, builds, CI, benchmarks, browser tests and more.</blockquote><p>The AI can make a change, run the verifier, see what happened and decide what to do next.</p><p>Basically:</p><p><strong>AI → Action → Test → Feedback → Fix → Test again</strong></p><h4>So Is Prompt Engineering Actually Dead?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cVgx03pa8t9PUMbq" /><figcaption>Photo by <a href="https://unsplash.com/@matmacq?utm_source=medium&amp;utm_medium=referral">Mathew MacQuarrie</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Again, I wouldn’t say that. Prompting is still useful.</p><p>But I think we are moving from thinking only about <strong>prompts</strong> to thinking about the <strong>whole system around the model</strong>.</p><p><strong>Prompt Engineering asks</strong>: “What should I tell the model?”<strong><br>Agent Engineering asks</strong>: “What can the model do?”<strong><br>Loop Engineering asks</strong>: “How should the whole system keep moving toward the goal, check its work, handle failure and know when to stop?”</p><p>That is a much bigger question. And this is where the term <strong>Loop Engineering</strong> becomes interesting. The idea is not that someone suddenly invented loops in 2026.</p><p>The research pack I went through shows that many of the ideas behind modern loops have existed for years through things like ReAct, Self-Refine, Reflexion, autonomous agents and iterative software development. What is changing now is that these ideas are becoming practical engineering patterns for modern LLM agents.</p><p>So I would describe it as an <strong>evolution</strong>, not a sudden invention.</p><h4>Where Does the “Loop” Actually Live?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oOPxb1dbpeSygKYC" /><figcaption>Photo by <a href="https://unsplash.com/@simonesecci?utm_source=medium&amp;utm_medium=referral">Simone Secci</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><strong>Model + Prompt + Tools + Environment + State + Verification</strong></p><p>The model decides what to do. The tools allow it to do something. The environment shows what happened. The verifier tells it whether the result is correct. The state allows it to continue from where it left off.</p><p>This surrounding system is sometimes called the <strong>agent harness</strong>.</p><p>SWE-agent, for example, demonstrated how important the environment around the model is. An agent needs to be able to read files, search code, edit files, run commands, run tests and inspect the results.</p><p>So when someone says:</p><p><strong>“AI is coding now.”</strong></p><p>There is actually a lot happening behind that simple statement.</p><h4>And Then There Is the Context Problem</h4><p>There is another problem that becomes obvious when you let AI work for a long time. The conversation gets huge.</p><blockquote>First you have the original task.<br>Then code.<br>Then errors.<br>Then test results.<br>Then more code.<br>Then more fixes.<br>Then more logs.</blockquote><p>Eventually, the AI has a massive amount of context to deal with.</p><p>So one interesting approach is to stop thinking of the conversation as the only place where the AI stores its state.</p><p><strong><em>This is where the Ralph technique, popularized by Geoffrey Huntley, becomes interesting.</em></strong></p><p>The basic idea is pretty simple. Let an agent work on the repository. End the session. Start a fresh agent. Let the new agent inspect the current repository state and continue. <br>The repository becomes part of the memory.</p><blockquote>Your source code. <br>Git diff. <br>Tests.<br>Plans.<br>Progress files.<br>Notes.</blockquote><p>All of these can tell the next agent what has already happened.</p><p>So instead of saying: <strong>“AI, please remember everything we talked about for the last five hours.”</strong></p><p>you can make the environment itself preserve the important state.<br>I think this is a really interesting way to think about AI memory.<br>The AI doesn’t necessarily need to remember everything.<br>The <strong>system needs to remember what matters</strong>.</p><h4>But Just Saying “Try Again” Is Not a Loop</h4><p>This is also where I think people can misunderstand the whole idea.</p><p>A loop is not:</p><blockquote><strong>“Try again.”<br>“Try again.”<br>“Try again.”</strong></blockquote><p><strong>That can easily become an infinite waste of tokens.</strong></p><p>A proper loop needs some structure.</p><blockquote>It needs a goal.<br>It needs actions.<br>It needs feedback.<br>It needs verification.<br>It needs some state.<br>It needs a stopping condition.<br>And it needs limits.</blockquote><p>Otherwise, the AI can keep doing the same thing forever.</p><p>A good loop should also know when it is stuck. If the same test fails five times and the agent keeps making tiny variations of the same change, maybe it is time to stop. Maybe it needs a different approach. Maybe it needs a human.</p><p>Autonomy does not mean the AI should continue forever.</p><h4>This Also Changes the Role of the Developer</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*er2YdBFwRk0H-Sw3" /><figcaption>Photo by <a href="https://unsplash.com/@juanjodev02?utm_source=medium&amp;utm_medium=referral">Juanjo Jaramillo</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>The part that interests me most is what happens after the AI makes its first attempt.</p><p>A normal AI coding session often ends with an answer. You read it, decide whether it looks right, and then continue from there.</p><p>A loop can make the software itself part of the conversation.</p><p>The agent changes something, runs the project, sees a test fail, reads the error, changes the code again, and checks again. The failure is not the end of the interaction. It becomes new information for the next step.</p><p>That changes the role of the codebase.</p><p>Instead of being just a place where the agent writes code, it becomes an environment that constantly gives the agent feedback.</p><p>And honestly, I think this is where things get interesting.</p><p>A strong loop does not need the AI to magically know the correct answer on the first try. It needs the environment to make wrong answers easy to detect and give the agent enough information to recover.</p><p>That could be a failing test, a type error, a broken build, a benchmark result, a browser check, or even a review from another agent.</p><p>The goal is not “make the AI perfect.”</p><p>The goal is to make the system good at <strong>trying, checking, learning from failure, and trying again.</strong></p><p>That feels like a much bigger shift than simply writing better prompts.</p><h4>A Simple Example From Open Source</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*fs_SzaUTEqkhgX6C" /><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>Let’s say you find a GitHub issue.</p><blockquote><em>Instead of: </em><strong><em>“AI, solve this issue.”</em></strong></blockquote><p>you can build a much better workflow. First understand the issue. Then inspect the repository. Reproduce the problem. Find the root cause. Create an implementation plan. Then let the coding agent implement it. Run the focused test. If it fails, inspect the failure. Fix the actual problem. Run the test again. Then run broader tests. Review the final changes. If everything passes, stop.</p><p>That is already a loop.</p><p>And honestly, this is very close to the workflow I use when working on open-source issues. The difference is that I don’t want AI making every decision blindly. I want AI to help with the work while I understand what is actually happening. That part is important.<br><strong>Using loops doesn’t mean giving your brain to the AI. </strong>It means giving the AI a better workflow.</p><p>U can Try this Simple Loop</p><pre>▸ SELF-CHECKING LOOP  (paste into Claude or ChatGPT)<br>You will work in a loop until the task meets the bar.<br><br>TASK:<br>[describe exactly what you want produced]<br><br>SUCCESS CRITERIA (be strict, no soft passes):<br>- [criterion 1]<br>- [criterion 2]<br>- [criterion 3]<br><br>LOOP PROTOCOL, repeat every turn:<br>1. PLAN   - state the single next step.<br>2. DO     - produce or improve the work.<br>3. VERIFY - score the result 1-10 on each criterion.<br>            Be brutally honest. List exactly what is still weak.<br>4. DECIDE - if every criterion is 8+, print &quot;FINAL&quot; and stop.<br>            Otherwise print &quot;ITERATING&quot; and go again, fixing<br>            the weakest point first.<br><br>RULES:<br>- Never call it done until every criterion is 8 or higher.<br>- Each pass must fix the weakest score from the last VERIFY.<br>- Do not ask me questions. Make a sensible assumption, note it,<br>  and keep going.<br><br>Begin. Run the loop until FINAL.</pre><h4>What Makes a Good AI Loop?</h4><p>For me, the easiest checklist is:</p><p><strong>Clear goal.<br>Useful tools.<br>Real feedback.<br>Reliable verification.<br>Persistent state.<br>Clear boundaries.<br>A stopping condition.<br>A way to handle failure.<br>Human intervention when needed.</strong></p><p>If these things are missing, you might just have an AI repeatedly doing random stuff.</p><p>If they are designed properly, you start getting something much closer to an autonomous engineering workflow.</p><h4>The Bigger Shift</h4><p>So coming back to the original statement: <strong>“Prompting is dead.”</strong></p><p>I don’t think that is the right way to understand it. I think prompting is becoming <strong>one layer of a much bigger system</strong>.</p><p><strong>We started with</strong>: Prompt → Answer<br><strong>Then we moved toward</strong>: Prompt → Agent → Tools<br><strong>And now we are moving toward:</strong> Goal → Agent → Tools → Environment → Feedback → Verification → Loop</p><p>That is a pretty big change. The question is no longer only:</p><p><strong>“How can I write the perfect prompt?”</strong></p><p>It is becoming:</p><p><strong>“How can I design a system where AI can keep working toward a goal and know whether it is actually making progress?”</strong></p><p>And that is what I find exciting about AI loops. One prompt can give you an answer. A loop can give the AI a <strong>process for solving a problem</strong>. Maybe that is the real shift happening right now. Not the death of prompting. But the beginning of something bigger.</p><h4><strong>Welcome to the era of Loop Engineering.</strong></h4><h3>Resources That Helped Me Understand This</h3><p>I went through a bunch of research and resources while trying to understand where this whole idea came from and how modern AI loops are being built.</p><p>I have added the important One’s</p><p><strong>Loop Engineering Research</strong><br><a href="https://arxiv.org/abs/2608.21884">https://arxiv.org/abs/2608.21884</a></p><p>@<a href="https://x.com/AnatoliKopadze"><strong>Anatoli Kopadze</strong></a><strong> Tweet on AI Loops<br></strong><a href="https://x.com/AnatoliKopadze/status/2068328135611822149">https://x.com/AnatoliKopadze/status/2068328135611822149</a></p><h3>Plzz Show Small Support❤️</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yPwQBk7p-V5R2YfYlJqKeg.png" /></figure><p>Guys, if you found this blog useful, please do support me.</p><p>A small <strong>like, follow or upvote</strong> really helps and would be highly appreciated.</p><p><strong>My-GitHub</strong>: <a href="https://github.com/AaryanRS">Click ME</a><br><strong>My-Instagram</strong>: <a href="https://www.instagram.com/shelar_1arynx/">Click ME</a></p><p><strong>Thank you for reading this far. ❤️</strong></p><h3>One Last Thing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qy16QhxwDrH8mMS1" /><figcaption>Photo by <a href="https://unsplash.com/@sasun1990?utm_source=medium&amp;utm_medium=referral">Sasun Bughdaryan</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I think we are entering a pretty interesting phase of AI. A few years ago, learning how to prompt AI was a new skill. Now, I think we are slowly moving toward a different skill:</p><p><strong>Learning how to build workflows around AI.</strong></p><p>And that doesn’t mean you need to immediately build some crazy multi-agent system with 20 different agents.</p><p>Start small.<br>Give the AI a goal.<br>Give it access to the right tools.<br>Give it a way to verify its work.<br>Let it try.<br>Let it fail.<br>Let it learn from the feedback.<br>And most importantly, <strong>know when to take control yourself.</strong></p><p>Because AI is getting better at doing the work. Our job is slowly becoming better at <strong>designing how that work gets done.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dad3eee537db" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Actually Contribute to Open Source for GSoC in AI Era…]]></title>
            <link>https://medium.com/@aaryan.r.shelar5418/how-to-actually-contribute-to-open-source-for-gsoc-in-ai-era-7a4915e9ce84?source=rss-a7cac932ef5b------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a4915e9ce84</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[gsoc]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Aaryan R Shelar]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 06:12:17 GMT</pubDate>
            <atom:updated>2026-10-28T07:31:41.181Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kKb4paALZ4tXHIDjnrLg8A.png" /></figure><p>Thinking about contributing to open source for GSoC 2027 but don’t know where to start?</p><p>In this blog, I am going to share what I have actually learned from my first few months of contributing to open source. I will talk about how to choose the right organization, understand a codebase, find the right issue, use AI properly, test your changes, communicate with maintainers, and create a good pull request.</p><p>I will also share the mistakes I made in the beginning, including a PR where I depended too much on AI and ended up getting my implementation completely wrong.</p><p>This is not a “never use AI” guide. I use AI a lot in my open source work, and it has helped me learn and work much faster.</p><blockquote>The important thing is to remember that <br><strong>AI can help you with the work, but understanding, reviewing, testing and making the final decision is still your responsibility.</strong></blockquote><p>So if you are planning to start contributing to open source for GSoC 2027, this is everything I wish someone had told me before I started.</p><h3>Open Source With AI</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6TdhLypBH1Sc_zIl" /><figcaption>Photo by <a href="https://unsplash.com/@steve_j?utm_source=medium&amp;utm_medium=referral">Steve A Johnson</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>A few months ago, I thought contributing to open source would be easy. I thought I could find an issue, use AI to understand it, make the changes, create a pull request and move on to the next one.</p><p>I was very wrong.</p><p>The hardest part of open source is actually <strong>starting</strong>.</p><p>When you are completely new to it, GitHub itself can feel confusing. You see repositories, issues, pull requests, branches, discussions, maintainers, documentation, tests, codebases and so many other things.</p><p>You don’t even know where to begin.</p><p>And then there is AI.</p><p>Today, you can open ChatGPT, Copilot, Claude or any other AI tool and ask it to explain code, find a solution or even write the changes for you.</p><p>So it can feel like:</p><blockquote>“Why should I struggle? I will just ask AI to do it.”</blockquote><p>And honestly, I understand why people think that.</p><p>I use AI for my open source work too.</p><p><strong><em>Using AI is not the problem. Being completely dependent on AI is.</em></strong></p><p>AI can help you understand a huge codebase. It can explain an issue in simple language. It can help you find where a problem might be coming from. It can write code. It can help you write tests. It can even help you understand an error you have never seen before. But there is one thing AI cannot take away from you:</p><h4>The responsibility of making the final decision.</h4><p>You are the one who has to review the changes. You are the one who has to test them. You are the one who has to decide whether the solution actually fixes the problem. And you are the one who has to explain your work to the maintainers.</p><p>Make one bad decision and your PR can get closed because the solution was wrong, even if AI confidently told you that it was correct.</p><p>I know this because it happened to me.</p><p>And that is exactly why I wanted to write this.</p><h4><strong>Hi, I’m Aaryan Shelar From India</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/1*qGhtPHcr-I1X8udOsY6FrQ.png" /></figure><p>For the past 2–3 months, I have been contributing to open source organizations while preparing for GSoC. But GSoC is not the only reason I am doing this.</p><p>I genuinely enjoy open source. <br>I like finding interesting projects. <br>I like understanding how huge codebases work. <br>I like building things. <br>I like solving problems that I have never seen before. <br>I like talking to maintainers and other contributors.</p><p>And honestly, I have started enjoying this so much that open source has become one of the things that keeps me busy outside college.</p><p>In these past few months, I have learned a lot. Not just about programming. I have learned how to work with GitHub properly. I have learned how to enter a completely new codebase without getting lost. I have learned how to understand GitHub issues. I have learned how to reproduce bugs before trying to fix them. I have learned how to communicate with maintainers. I have learned how to write better pull requests. And most importantly, <strong>I have learned from my mistakes.</strong></p><p>Because trust me, some of the things I did when I started were really bad. Looking at my old PRs today, I sometimes think:</p><p><em>“Why did I even submit this?”</em></p><p>And that is actually the reason I wanted to write this article.</p><p>There are already so many resources online about how to get started with open source. There are also many people who have shared their GSoC journeys. Those resources are useful.</p><p>But when I started, I still felt like something was missing.</p><p>People tell you how to start. Very few people tell you <strong>what happens after you start.</strong></p><blockquote>What problems are you actually going to face?<br>How do you choose the right organization?<br>How do you know which issue to pick?<br>What should you do before touching the code?<br>How do you understand an issue properly?<br>How do you use AI without blindly trusting it?<br>How do you test your changes?<br>How do you write a good PR description?<br>How do you communicate with maintainers?<br>What happens when your PR gets rejected?<br>And what should you do when you make a mistake?</blockquote><p>These are the things I wish someone had explained to me before I started. So this is not going to be another article where I simply tell you:</p><p>“Fork the repository, solve an issue and create a PR.”</p><p>I want to show you what my journey actually looked like.</p><p>The good parts.<br>The stupid mistakes.<br>The bad PRs.<br>The rejected PR.<br>The things AI got wrong.<br>The things I learned.<br>And the process I follow today.</p><p>Because once you get a proper grip on open source, it becomes incredibly fun.</p><p>But getting that grip in the beginning? — -&gt; That is the hardest part.</p><p><strong>And this is where my journey started.</strong></p><h3>How I Started Contributing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Q87RYmANQa1OrCGg" /><figcaption>Photo by <a href="https://unsplash.com/@setyaki?utm_source=medium&amp;utm_medium=referral">Irham Setyaki</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><blockquote><strong><em>So now let me tell you how I actually started contributing to open source.</em></strong></blockquote><p>My journey started when I first came across the GSoC website.</p><p>I was looking through the organizations that participate in GSoC, trying to understand what kind of projects were available.</p><p>Then I came across <strong>HumanAI.</strong></p><p>And honestly, I was immediately interested.</p><p>I have always been interested in psychology and AI, so an organization that was working around both of those areas felt like something I actually wanted to explore.</p><p>So I went to the HumanAI website first. From there, I found their GitHub repository. I opened the repository, looked through the source code, forked it to my GitHub account and then cloned my forked repository onto my computer.</p><p>And just like that… I had entered the world of open source. At that point, I already knew Python very well and was confident with it. I had also spent a lot of time learning prompt engineering and was quite comfortable with AI tools. I knew GitHub to some extent as well</p><p>But contributing to a real open source codebase was completely different.</p><p><em>I was told to start small.</em></p><p>So instead of trying to solve some huge complicated problem, I looked for small issues that I could work on.My first contribution was basically improving the README.Then I worked on two more small issues.And somehow, within around three days, I had created three PRs.</p><p>At that time, I was extremely excited.</p><p>I thought:</p><blockquote>“Okay, I am actually contributing to open source now.”</blockquote><p>But looking back at those PRs today… They were honestly pretty bad. The biggest reason?</p><p><strong>I was using AI for almost everything.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iEBEGMvzx6A_VF8Z" /><figcaption>Photo by <a href="https://unsplash.com/@jannerboy62?utm_source=medium&amp;utm_medium=referral">Nick Fewings</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I was basically giving the issue to AI, letting it help me solve the problem and then using the output without really understanding everything myself.</p><p>Even the PR description was something I mostly copied from what AI generated for me.</p><p>At that time, I didn’t really understand why that was a problem.</p><p>I thought:</p><blockquote>“The description explains the changes, the code works, so what’s wrong?”</blockquote><p>I would understand that much later.</p><p>Another thing I noticed was that the organization had only a few open issues — around four when I checked — while there were somewhere around 43 pull requests. I also noticed that the maintainers were not very active at that time. And that matters. Because when you are new to open source, having active maintainers can make a huge difference.</p><blockquote>You can ask questions.<br>You can get feedback.<br>You can understand whether you are moving in the right direction.</blockquote><p>In my case, things were a little different.</p><p>And I also started around September, which later I realized was important because the activity around GSoC preparation changes depending on the time of the year. I didn’t know any of this when I started. I was just happy that I had created my first few PRs.</p><p>But those first few contributions taught me something very important:</p><p><strong>Creating a PR is not the same thing as making a good contribution.</strong></p><p>After those first few PRs, I slowly started realizing that I was missing a lot of basic knowledge.</p><blockquote>I knew how to fork a repository.<br>I knew how to clone it.<br>I knew how to make changes and create a PR.</blockquote><p>But I did not really understand how open source works as a whole. So I started searching. I came across a few websites and resources that helped me understand GitHub, open source and contribution workflows much better.</p><p>I have added links to those resources and website at the End of this post… I know how confusing it feels when you are starting and don’t even know what you should search for.</p><h3>GAME CHANGER</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*c5tehAo-YVcmzLzU" /><figcaption>Photo by <a href="https://unsplash.com/@morshiba?utm_source=medium&amp;utm_medium=referral">Morshiba</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><strong>Finding Python and FURY on GSoC was something that completely changed my direction.</strong></p><p>While looking through GSoC organizations, I came across <a href="https://python-gsoc.org/index.html"><strong>Python</strong></a><strong>.</strong></p><p><a href="https://python-gsoc.org/index.html">Python GSoC - Home</a></p><p>Python participates in GSoC as an umbrella organization, which means multiple open source projects can participate under it.</p><p>And one of those projects was <strong>FURY</strong>. When I first looked at FURY, I immediately thought:</p><blockquote>This is exactly what I want to work on.</blockquote><p>FURY is a Python project focused on visualization. And for me, this was perfect. I love building things where I can actually see the result of my code. With FURY, I could write Python code and create visualizations that were not just something sitting inside a terminal. I could actually see what I was building.</p><p>That made me genuinely excited to contribute.</p><p><em>Some of the COOL things i have created Using FURY</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ekQKdjdDWVJ3smvBj-pHPg.png" /><figcaption>This is a complex 2000 connected nodes structure created using FURY.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nWg7xzMhKIGjnN0-1ZgFkA.png" /><figcaption>Tried to Create a complex Molecule Structure using FURY</figcaption></figure><h3><strong>And I want to take a moment here to thank all the mentors and maintainers of FURY who have helped me during this journey.</strong></h3><p>When you are new to open source, having people who are willing to answer your questions, review your work and point you in the right direction makes a huge difference.</p><p>I was still very new at this point. I had a lot to learn about the codebase.</p><p>So before jumping into issues, I started using different tools and resources to understand how FURY was structured, how its code worked and where different parts of the project were located.</p><p>I also started joining the community spaces around the project.</p><blockquote>Discord.<br>Forums.<br>Chats.<br>Discussions.</blockquote><p>And slowly, I started getting familiar with the people and the project. This was very different from my first experience. I was not just looking at a GitHub repository anymore. I was actually becoming part of the community. And then I found an issue that I wanted to work on.</p><p><strong>That was when things got serious.</strong></p><p>Because this time, I decided to use AI in a completely different way.</p><p># My First Real Issue With FURY</p><p>After spending some time understanding FURY and getting familiar with the community, I finally decided to work on a proper issue. At this point, I was still very comfortable using AI. Actually, maybe a little too comfortable. I copied the issue and the whole discussion around it and put it into my AI chat. I wanted the AI to understand what was happening, what people had already discussed and what kind of solution might work. The AI gave me some explanations and then gave me a prompt for another AI tool. I then took that prompt and put it into GitHub Copilot, which was connected to my cloned FURY repository. And then Copilot started making the changes for me. At that time, I thought this was amazing. I was sitting there watching AI work on an actual open source codebase. It looked like I had everything figured out. The code was being changed. The issue was being worked on. And I was getting closer to creating my PR.</p><p>So I created the PR.</p><p>For the PR description, I did something a little different. I did not simply copy a complete AI-generated description like I did in my earlier PRs. I wrote it myself and then used AI to help me check the grammar and formatting. I thought I had done everything properly.</p><p>But a few days later, I got a message from one of the mentors. And that message completely changed how I looked at open source. The implementation I had made was wrong.</p><p>Not just a small mistake.</p><p>The mentor explained that my implementation would actually create more problems instead of properly solving the issue.</p><p><strong>And my PR was closed 😭</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3WNFQO5CKpPzgq9b_K-v1Q.png" /></figure><p>I am not going to lie. <strong>That hurt.</strong></p><p>I was not just upset because my PR got closed. I was upset because I realized something much bigger.</p><p>I had done a lot of the work through AI without properly understanding the actual problem myself. I had trusted the output because it looked correct. And that was the mistake. At that moment, I started thinking:</p><p><em>What image did I just create about myself?</em></p><p>A person who opened an issue, gave it to AI, accepted the solution and submitted a PR without properly understanding the code.</p><p>That was honestly a very bad feeling.</p><p>But looking back now, I am actually glad that this happened. Because this was probably one of the most important moments of my open source journey.</p><p>It taught me that there is a huge difference between:</p><blockquote>`<strong>using AI to help you work</strong>` and `<strong>letting AI do the thinking for you</strong>`</blockquote><p>AI did not force me to make that bad decision.</p><p><em>I made the decision.<br>I was the one who accepted the implementation.<br>I was the one who did not understand it deeply enough.<br>I was the one who did not test and question it enough before creating the PR.</em></p><p>And that is the part I want every beginner to understand.</p><p>You can use AI. You can use it a lot.</p><p>But you cannot give AI the responsibility of deciding whether your solution is actually correct. That responsibility is still yours. And honestly, this is where I think many people preparing for GSoC give up. You start contributing. You spend hours on something. You finally create your PR. And then someone tells you that your solution is wrong.</p><p>It can feel horrible. You might even start thinking:</p><blockquote>“Maybe I am not good enough for open source.”</blockquote><p>But getting something wrong does not mean you should stop. It means you found something you need to understand better.</p><p>For me, this rejection became a turning point.</p><p>I started changing the way I use AI.</p><p>I started asking AI to help me <strong>understand</strong> before asking it to help me <strong>change the code</strong>. And slowly, my entire workflow started changing. That is when I finally started understanding what contributing to open source actually meant.</p><h4>What I Changed After That Basically Current ME</h4><p>After that PR was closed, I did not stop using AI. Actually, I did almost the opposite. I started using it much more carefully. The biggest change I made was very simple: I stopped asking AI to solve the entire issue for me. Now, when I find an issue, I first try to understand it myself.</p><p>I read the issue.<br>I read the whole discussion.<br>I look at what other people have already tried.<br>I understand where the problem is coming from.<br>And then I try to think about the solution myself.</p><p>Sometimes I write a small piece of code separately just to test my idea.<br>Sometimes I create a small demo to understand whether my solution actually works.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SfKwqx_zQtKa6M8K80G4tQ.png" /><figcaption>Demo for Testing the Thickness of each Line</figcaption></figure><p>And only after I have my own solution in mind, I bring AI into the process. This is one of the biggest changes in the way I work now.</p><p>For example, let’s say I have already figured out the code or logic that I think should solve the issue.</p><p>I don’t simply tell AI:</p><blockquote>“Solve this issue.”</blockquote><p>Instead, I tell it something more like:</p><blockquote>“This is the issue. This is what I understood. This is the solution I came up with. Now help me integrate this solution properly into the existing codebase.”</blockquote><p>Then I give that to my coding AI. In my case, I usually use tools like GitHub Copilot or Codex for the actual code changes. The AI already has access to the cloned repository and the instructions I gave it about the project.</p><p>So now it is not deciding everything for me.</p><p>It is helping me take my solution and properly integrate it into the actual project. And that difference is huge. Earlier my workflow was basically:</p><blockquote>Issue → AI → Code → PR</blockquote><p>Now it is more like:</p><blockquote><em>Issue → Understand → Reproduce → Think → My Solution → AI → Integrate → Review → Test → PR</em></blockquote><p>I still use AI heavily. The difference is that I am now driving the process.</p><h3>AI Is Not Weak. Your Prompt Is Weak.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zYGPw7_Ay11sraH5" /><figcaption>Photo by <a href="https://unsplash.com/@cooperhofmann?utm_source=medium&amp;utm_medium=referral">Cooper Hofmann</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>One thing I learned while doing all this is that the quality of the output you get from AI depends a lot on how well you explain the task.</p><p><strong>A weak prompt gives you a weak understanding. A detailed prompt gives the AI much more context to work with.</strong></p><p>So before I started working on issues seriously, I created a few prompts that I could reuse. For example, I keep a prompt for understanding the organization and its codebase.</p><p>The idea is simple.</p><p>I tell the AI to act like someone who has deep knowledge of that particular project and ask it to help me understand:</p><p>- how the project is structured<br>- where different parts of the code are located<br>- how the important APIs work<br>- how the project is tested<br>- how contributors are expected to work<br>- what I should know before touching the code</p><p>I also keep another prompt for my coding AI. This one is much more strict. I don’t want the AI to randomly change things across the project. I want it to first analyse the issue, understand the current implementation, identify exactly where changes are needed and then make only the required changes.</p><p>I also tell it things like:</p><p>- don’t change existing APIs unless the issue requires it<br>- don’t modify unrelated code<br>- don’t commit or push anything<br>- don’t make changes before analysing the problem<br>- add tests when required<br>- maintain the existing coding style<br>- keep proper documentation and docstrings<br>- tell me what changes were made</p><p>Prompt I use for Coding Agent →</p><pre>problem statement - <br><br>This problem statement is from [----] organisation selected in GSoC and I am solving this issue and contributing to that organisation.  <br>You are an analyzer bot with decades of experience in analyzing code files and writing test cases.  <br>I will provide you with a problem statement, the related code, and the tracker ID.  <br><br>Your job is to follow this structured process:<br><br>**Step 1: Issue Classification**<br>- First, read my summary of the issue.  <br>- Identify whether this is a bugfix, a new implementation, or another type of change.  <br>- Do not propose code yet — just confirm the classification with me.<br><br>**Step 2: Execution Plan**<br>- Before making any changes, outline the exact processes you will execute (analysis, fix, test creation, etc.).  <br>- Wait for my approval before continuing.<br><br>**Step 3: Code Analysis**<br>- Explain the code deeply, step by step, so I understand what it does.  <br>- Identify the exact problem in the code and describe why it occurs.  <br><br>**Step 4: Solution**<br>- Write out the full corrected solution, showing me what the final output should look like once fixed.  <br>- Clearly explain the approach you used to fix it, so I can learn the reasoning.  <br>- IMPORTANT: Use Fury’s existing APIs and functions unless a new implementation is absolutely required.  <br>- Mention the exact line(s) where you added or fixed the code.  <br><br>**Step 5: Testing**<br>- Generate proper test cases that reproduce the bug before the fix and pass after the fix.  <br>- Add assertions that validate the expected behavior.  <br>- Reference the tracker ID in comments inside the test code (e.g., `# tracker #80546`).  <br>- Keep the tests small, focused, and runnable with the existing test suite.  <br>- Follow Fury’s contributor guidelines: confirm whether tests are required for bugfixes as well as new features, and apply them accordingly.  <br><br>**Step 6: Verification**<br>- Guide me to test the issue myself first (e.g., check behavior in older vs newer Fury versions).  <br>- Show me how to run the tests to confirm the fix works.  <br>- If relevant, suggest a rough check to ensure codebase structure and style are consistent.<br><br>**Step 7: Explanation**<br>- Once the issue is solved, explain the fix to me like I’m 19 years old — in simple terms I can easily understand, focusing on the logic and reasoning behind the change.  <br>- Also draft a short, mentor‑friendly explanation in my tone style (clear, simple, not AI‑driven jargon) that I can paste into the PR description or comments.<br><br>Do not leave the solution or the tests incomplete — I want the finished corrected code and the finished test code together.</pre><p>I keep these prompts saved in a notepad so I don’t have to rewrite everything every time. And honestly, this made my work much easier.But remember something.</p><p><strong>A good prompt does not mean you can stop thinking.</strong></p><p>You still have to read what AI gives you. You still have to question it. You still have to test it. And most importantly, you still have to decide whether the solution actually makes sense.</p><p>That is the biggest lesson I learned from my first rejected PR.</p><p><strong>Use AI as your tool. Don’t make AI the person making the decisions for you.</strong></p><h3>Here’s How to Actually Contribute to Open Source</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*T4MPqPwjJ6ugidru" /><figcaption>Photo by <a href="https://unsplash.com/@buddhaelemental3d?utm_source=medium&amp;utm_medium=referral">Buddha Elemental 3D</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Now that you know my story, let me show you the actual process I follow. This is the part I really wish someone had given me when I was starting.</p><p>I’ll keep it as simple as possible.</p><h4><strong>Step 1: Choose the Right Organization</strong></h4><p>Before you start looking for an issue, the first thing I want you to do is choose the right organization. Don’t just open the GSoC website, see an organization that looks interesting and immediately start working on it.</p><p>Take some time and do a little research. The organization you choose is very important.</p><p>Here are the things I usually look for.</p><p><strong>1.</strong> Check how active the organization is Open their GitHub repository and look at what is happening recently. Look at the latest issues. Look at recent pull requests. See whether maintainers are reviewing PRs. See whether contributors are communicating with each other. You don’t want to spend a lot of time working on an issue and then find out that nobody is active in the project.</p><p><strong>2. </strong>Make sure there are issues to work on Go through the issues section. See what kind of problems people are reporting. Look for bugs, improvements, documentation issues, new features and smaller tasks. You don’t need to solve something huge on your first day. The important thing is that the organization should actually have things you can contribute to.</p><p><strong>3.</strong> Check its GSoC history Since I am preparing for GSoC, this is something I personally look at. I usually try to keep 3 organizations in mind: 2 organizations that have consistently participated in GSoC and 1 organization that has recently started participating in GSoC.</p><p>The reason is simple.</p><p>For the two organizations that regularly participate, you already know that they have been part of GSoC before. <br>For the newer organization, if they participate again in the next cycle, you already have experience with their project and community.</p><p>This is my personal strategy.</p><p>I am not saying you have to follow it exactly. But I would definitely recommend having more than one organization that you genuinely like. Don’t put all your hopes on one organization.</p><p><strong>4.</strong> Check whether you understand the language and codebase This is very important, Look at the programming language the project uses. If you know Python, a Python project will obviously be easier for you to start with. I love Python from the bottom of my Heart so I love contributing to python based Orgs.<br>If you know JavaScript or TypeScript, look for projects using those languages. You don’t need to be an expert.</p><p><strong>But you should at least have enough knowledge of the language to understand what the code is doing.</strong></p><p>Because this goes back to what I said earlier.</p><blockquote>AI can explain code to you.<br>AI can write code for you.<br>AI can suggest solutions.</blockquote><p><strong>But if you don’t understand the language or the code at all, it becomes very easy to accept a wrong solution without even realizing it.</strong></p><p>So choose something where you have at least a basic foundation.</p><h4>Go Through the Organization’s Website</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LKCN_95nW9NcHpS7" /><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>Once you find an organization you like, go to its website. Don’t directly jump into GitHub issues. The organization’s website can give you a lot of information that will make everything easier later.</p><p>You may find:</p><p>- documentation<br>- API documentation<br>- examples<br>- installation instructions<br>- contributor guidelines<br>- Discord or chat links<br>- forums<br>- the GitHub repository<br>- information about maintainers<br>- information about different parts of the project</p><p>Go through these things. You don’t have to understand everything. Just try to answer some basic questions:</p><blockquote>What does this project actually do?<br>Who uses it?<br>How is it structured?<br>Where do contributors communicate?<br>Where can I find the documentation?<br>Where is the actual source code?</blockquote><p>This small amount of research can save you a lot of confusion later.</p><h4>Get Familiar With the Codebase</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wW5JAp_v7wudsDGF" /><figcaption>Photo by <a href="https://unsplash.com/@yenvu2410?utm_source=medium&amp;utm_medium=referral">Yen Vu</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Now you have your organization. You have found the GitHub repository. You fork it. Then you clone your fork onto your computer. And now you have the whole project sitting on your computer.</p><p>But please don’t do this: Okay, I have cloned the repository. Now let me find an issue and start coding. NOOOO…</p><p>Before your first issue, spend some time getting familiar with the codebase. And no, I am not saying you need to read every single file. Please don’t do that. You will get overwhelmed very quickly 😂.</p><p>Start with the important files.</p><p><strong>Read the README</strong></p><p>It usually contains basic information about the project, installation instructions, how to run it and sometimes information about the structure of the project.</p><p><strong>Read the contribution guidelines</strong></p><p>Look for something like: `CONTRIBUTING.md` or any other contributor documentation. This is very important because every project can have different rules.</p><blockquote>Some projects have specific testing requirements.<br>Some have coding standards.<br>Some have rules for commit messages.<br>Some have a particular PR format.</blockquote><p>Read it before you start contributing.</p><p><strong>Look around the repository</strong></p><p>You may also find documentation, tests, examples, configuration files and other files that help you understand how the project is organized. Again, you don’t need to read everything. Just understand where the important things are. At this point, your goal is very simple. You should be able to look at the repository and say:</p><p>“Okay, I understand what this project does, I roughly understand how it is organized, and I know where I should look when I need something.”</p><p>That’s enough. You are not trying to become an expert on the entire project in one day. And this is where AI can help you a lot. Take the codebase and use an AI chat tool to help you understand how it is structured.</p><p>In my case, I use AI for codebase analysis because some open source repositories can be very large and confusing when you see them for the first time.</p><p>But remember: <strong>Use AI to understand the codebase. Don’t use AI as an excuse to skip understanding the codebase.</strong></p><p>Ask it questions. Go step by step. Let it explain one part at a time. And keep asking questions until you actually understand what you are looking at. Because before you work on your first issue, you should at least know what you are touching.</p><h4>Step 2: Prepare Your AI Before Working on an Issue</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dK0tI5lI4KpmCdSH" /><figcaption>Photo by <a href="https://unsplash.com/@andrewtneel?utm_source=medium&amp;utm_medium=referral">Andrew Neel</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Now that you have chosen your organization and have a basic understanding of the codebase, there is one more thing I want you to do before jumping into your first issue.</p><p><em>Prepare your AI properly.</em></p><p>I usually use two different AI tools for this. <em>One AI is there to talk with me, understand the issue and help me think</em>. <em>The other AI is there to make the actual code changes inside my cloned repository.</em></p><p>For example, I use ChatGPT or Copilot for the first part and GitHub Copilot or Codex for the second part.</p><p>The reason I use two different tools is simple. I don’t want my coding AI to immediately start changing files before I even understand what the issue is. First, I want to understand. Then I want to decide what needs to be done. Then I want the coding AI to help me implement it.</p><h4>Step 3: Choose the Right Issue</h4><p>Now that you have chosen your organization, understood the basic structure of the codebase and prepared your AI workflow, it is finally time to choose an issue.</p><p>And trust me, don’t randomly pick one.</p><p>The issue you choose can make your first contribution either much easier or much harder.</p><p><strong>Start With the Issue Labels</strong></p><p>Some organizations use labels like:</p><blockquote>`good first issue`<br>`bug`<br>`enhancement`<br>`new feature`<br>`documentation`</blockquote><p>If your organization uses these labels, they can be a good place to start. But don’t think: <em>“Oh, this says `good first issue`, so it must be easy.” </em>Not necessarily. The label only gives you an idea of what the issue is. You still need to understand the actual problem before deciding whether you can work on it.</p><p><strong>Don’t Always Go for the Oldest Issue</strong></p><p>You might find issues that were opened one year ago, two years ago or even longer. Don’t immediately assume that an old issue is a good one to pick. Sometimes the problem may already have been fixed because the codebase has changed. Sometimes the issue may no longer be relevant. Sometimes someone may already be working on it. Sometimes the project may have moved to a newer version and the old issue doesn’t even happen anymore.</p><p>So I usually look at newer issues first. This doesn’t mean old issues are bad. It just means you should check whether the issue is still relevant before spending your time on it.</p><p><strong>Read the Entire Issue</strong></p><p>Once you find an issue that looks interesting, don’t start coding immediately. Read the issue. Then read the discussion below it. Then read what other contributors have said. Then read the replies from maintainers. If someone has already suggested a solution, read that too. If someone tried to fix it and their PR was rejected, read why. This is extremely useful because sometimes the answer to your problem is already hidden inside the discussion. And sometimes you can learn more from a rejected solution than from a successful one.</p><p>For example, you might find:</p><blockquote>&gt; Contributor A suggested one solution.<br>&gt; Maintainer explained why it would break another part of the project.<br>&gt; Contributor B suggested something else.<br>&gt; Maintainer explained what they actually wanted.</blockquote><p>Now you already have a lot of information before writing a single line of code.</p><p><strong>Don’t Ask AI to Fix It Yet</strong></p><p>This is one of the most important things I want you to remember. After reading the issue, don’t immediately paste it into AI and ask: <em>“How do I fix this?” </em>First ask AI to help you understand the issue. I usually copy the issue title and the whole discussion and give it to my AI. Then I tell it something like: <em>“Explain this issue to me in very simple English. Tell me what the actual problem is, when it happens and what the discussion is saying. Don’t give me a solution yet.”</em></p><p>I want the AI to explain:</p><blockquote>What is the problem?<br>Why is it a problem?<br>When does it happen?<br>What part of the code might be involved?<br>What have people already tried?<br>Why did those attempts work or fail?</blockquote><p>I do not want the solution yet. Because if you don’t understand the problem, how are you going to know whether the solution AI gives you is correct?</p><p><strong>Reproduce the Issue Yourself</strong></p><p>This is something I strongly recommend. Try to reproduce the issue yourself before fixing it. Ask your AI to help you create a small example or demo that shows the problem.</p><p>Then run it on your own computer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wm85NMKQXzL6ZAqIGjZHug.png" /><figcaption>This is one of the Demo tests code I Ran to see the issue Behaviour</figcaption></figure><p>If you get the same result that the person who opened the issue got, that’s a very good sign. Now you have your own evidence. Take a screenshot of the output or error. This is useful for two reasons.</p><p>First, now you actually know that the issue exists in your environment.</p><p>Second, when you eventually communicate with the maintainer, you can show that you didn’t just read the issue and start guessing.</p><p>You actually tested it.</p><p>Tell the Community You Reproduced It. Once I have reproduced an issue, I like to leave a small message in the discussion. Nothing huge.</p><p>Something simple like:</p><p><em>“I tested this issue locally and was able to reproduce the same error. I have also looked into where the issue seems to be coming from, and I will work on a possible solution and open a PR.”</em></p><p>U can see my Discussion with maintainers for this ️particular issue → <a href="https://github.com/holoviz/datashader/issues/1404">Click ME</a>… before opening a PR</p><p>This is a small thing, but it tells the maintainers: <em>“I am actually working on this.” </em>And it also gives you a chance to check whether someone else is already working on the same issue.</p><p>Take Your Time Understanding the Issue, Now comes the part where I want you to slow down. Don’t let AI give you ten pages of explanation and then immediately start changing code.</p><p>Tell your AI: Let’s go step by step. Ask it to explain one thing at a time. First understand the issue. Then understand where the problem comes from. Then understand the relevant code. Then think about possible solutions. Only after you understand all of that should you move towards implementation.</p><p>I usually ask my AI to explain things in very simple English because I don’t want a huge technical explanation that I don’t understand. <br>I mostly Expect AI to give me Output in <strong>ASD-STE100</strong> format.</p><h4>Step 4: Think About the Solution Before Asking AI to Code</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1MmsrFgopf2qr96l" /><figcaption>Photo by <a href="https://unsplash.com/@heyquilia?utm_source=medium&amp;utm_medium=referral">Quilia</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Now you understand the issue. You have reproduced it. You know what is going wrong. You have looked at the code where the problem seems to be coming from. So now it is time to think about the solution. And <strong>this is where I made one of my biggest changes.</strong></p><p><em>First, Try to Solve It Yourself</em></p><p>Before asking your coding AI to make changes, try to come up with your own solution first. I don’t mean that you need to have the perfect solution. You might be wrong. You might find a better solution later. That’s completely fine. The point is that you should think first.</p><p>Ask yourself:</p><blockquote>&gt; What is actually causing the problem?<br>&gt; Which part of the code needs to change?<br>&gt; What should happen instead?<br>&gt; Will this change affect anything else?<br>&gt; Do I need a test for this?</blockquote><blockquote>Sometimes I write the solution separately in a small file first.<br>Sometimes I write a small piece of code just to test my idea.<br>Sometimes I simply write down the logic before touching the actual repository.</blockquote><p>This is important because now I am not asking AI: <em>“Please solve this issue for me.” </em>I already have an idea. <strong>I am asking AI to help me integrate my solution into the actual codebase.</strong></p><p>Once I have my own solution, I give the issue, the discussion, my understanding and my proposed solution to my coding AI.</p><p>For example, I might tell it:</p><p><em>“I have understood the issue and reproduced it locally. I believe the problem comes from this part of the code. My proposed solution is this. Now analyse the existing codebase and help me integrate this solution properly without changing unrelated behaviour.”</em></p><p>The AI is still doing a lot of work for me. It can find the right files. It can help me understand the existing implementation. It can write or modify code. It can suggest tests. It can help me find problems in my own approach.</p><p><strong>But the main idea came from me.</strong></p><p><strong>Tell Your Coding AI What It Should Not Do</strong></p><p>This is also where your detailed coding-agent prompt becomes very useful. I don’t want my AI to suddenly rewrite the whole project because it thinks that would be a cleaner solution.</p><p>For example, if I am fixing one bug, I don’t want it to:</p><blockquote>- change unrelated APIs<br>- rewrite working code<br>- modify unrelated files<br>- remove existing behaviour<br>- change public interfaces without a reason<br>- commit anything<br>- push anything to GitHub</blockquote><p>So I make all of this very clear in my prompt. I also ask it to first analyse everything before making changes.</p><p>Something like:</p><p>&gt; First understand the issue.<br>&gt; Find the relevant code.<br>&gt; Explain what needs to change.<br>&gt; Wait until the solution is clear.<br>&gt; Then make only the required changes.<br>&gt; Do not modify unrelated parts of the project.<br>&gt; Do not commit or push anything.</p><p>Don’t Just Accept the Changes Once the AI has made the changes, stop and read them. Don’t immediately think: <em>“Great, it works. Let’s make a PR.” </em>Look at the files it changed. Look at the actual code. Compare it with the code that was there before.</p><p>Ask yourself:</p><blockquote>Did it change only what was necessary?<br>Does the implementation match the solution I had in mind?<br>Did it accidentally change an existing API?<br>Did it introduce unnecessary code?<br>Are the tests still correct?<br>Do I need to add a regression test?</blockquote><p>This is where your understanding of the codebase becomes extremely important. Because even if AI makes the changes correctly, you still need to review them.</p><p><strong>Tests Are Not Optional </strong>Depending on the issue, you may need to add or update tests. For a bug fix especially, you generally want some kind of test that proves:</p><p><em>`</em><strong><em>the old behaviour was wrong</em></strong><em>` and `</em><strong><em>the new behaviour is correct.</em></strong><em>`</em></p><p>For Example :- See this PR I have Created → <a href="https://github.com/holoviz/datashader/pull/1544"><strong>Datashader_issue_1380</strong></a></p><p>You also want to make sure that your change does not break something that was already working. That is why regression tests can be very important. Again, the exact testing requirements depend on the project and the issue. Always check what the organization expects.</p><p><strong>AI Can Help You Test Too</strong></p><p>After the changes are made, I usually ask AI to help me create code that tests the changes. But again, I don’t just trust the output. I run the test myself. I see the result myself. If something fails, I investigate it. If the output is different from what I expected, I stop and figure out why.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/988/1*rbgpygbjuqsyphXXiXaIwg.png" /><figcaption>I use these type of test images to stregthen my PR description…</figcaption></figure><p>At this point, you should have:</p><blockquote>understood the issue → reproduced it → thought about your own solution→ integrated that solution into the codebase with AI → reviewed the changes → added or updated tests where needed</blockquote><p>Now there are still a few important things left before you create your PR.</p><h4>Step 5: Test Everything Before Opening Your PR</h4><p>Your changes are done. Now test them properly before opening the PR. You don’t want a maintainer to open your PR and immediately find that your code doesn’t even pass the project’s tests.</p><p><strong>First, Test the Issue Again</strong></p><p>Run the same demo you used when you first reproduced the issue. You want to see whether the problem is actually fixed. Before your changes, the issue should happen. After your changes, it should no longer happen.</p><p>This gives you a very simple way to prove that your implementation actually worked. And this is also useful when you write your PR description later.</p><p><strong>Run the Project’s Tests</strong></p><p>Most open source projects have their own test suite. For Python projects, you will often see things like `<strong>pytest</strong>`. For other projects, the command can be completely different. So first check the project’s documentation and contributor guidelines to see what they recommend.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SCQs0uJJ9B_mqFvnDASkPw.png" /><figcaption>Something Like this</figcaption></figure><p>You don’t need to memorize every command. You can ask your AI: <em>“Give me the correct test command for this project and explain what it does.” </em>But make sure you actually understand what you are running.</p><p><strong>Run Ruff or the Project’s Code Checks</strong></p><p>For Python projects, I also commonly use `<em>ruff</em>` to check the code. Ruff can catch things like code-quality problems, formatting issues and other problems depending on how the project is configured.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Tl1OLtjqrRytUhJmdOOlmg.png" /><figcaption>NGL it took be 3 hours To FIX and get ALL checks passed</figcaption></figure><p>Again, your project may use something completely different like :</p><blockquote>Some projects use different linters.<br>Some use formatters.<br>Some have pre-commit hooks.<br>Some have a single command that runs everything.</blockquote><p><strong>Follow the project’s own instructions.</strong></p><p><strong>Check What Actually Changed</strong></p><p>Before opening your PR, look at exactly what changed. You can use:</p><blockquote>git diff<br>git status</blockquote><p>Sometimes AI can make a small change in a file that you did not expect. Sometimes it can modify something unrelated. Sometimes you might have accidentally changed a formatting line somewhere else. Looking at your diff helps you catch those things.</p><p>This is basically your final inspection before sending the code to someone else.</p><p><strong>Run Everything One More Time</strong></p><p>After checking the diff, run your tests again. Yes, again. After your final changes, test again.</p><p><strong>Ask AI to Help You Review</strong></p><p>You can give your AI the final diff and ask: <em>“Review these changes as if you are a maintainer. Tell me about possible bugs, unnecessary changes, missing tests, API compatibility problems and anything I should check before opening the PR.”</em></p><p>This can be very useful. You might catch something you missed. But you still need to verify the suggestions yourself.</p><p><strong>Your Final Checklist</strong></p><p>Before creating the PR, I personally want to be able to say:</p><blockquote>I reproduced the issue.<br>I understand why it was happening.<br>I have a clear solution.<br>I made the required changes.<br>I reviewed the code.<br>I added or updated tests where needed.<br>The original issue is now fixed.<br>The existing tests still pass.<br>The project’s linting or formatting checks pass.<br>I checked my Git diff.<br>I didn’t accidentally change unrelated code.</blockquote><p>If all of that is good, now you are ready. And only now should you move towards creating the pull request.</p><p><strong>Step 6: Create Your Pull Request</strong></p><p>You have understood the issue. You reproduced it. You worked on the solution. You tested your changes. Now it is time to create your Pull Request.</p><p>Before doing anything, make sure you are still working on your → `<em>issue branch</em>` and not your `<em>main</em>` branch. I usually create a separate branch for every issue I work on.</p><p>For example:</p><blockquote>git checkout -b issue-name</blockquote><p>Whatever changes you make now will stay inside this branch. Your `<em>main</em>` branch stays clean. And when you need to work on another issue later, you can create another branch for that issue.</p><p>Add and Commit Your Changes</p><blockquote>git status<br>git add .<br>git commit -m “Describe your change here”</blockquote><p>And finally push the branch to your forked GitHub repository:</p><blockquote>git push origin issue-name</blockquote><p>Again, you don’t need to become a Git expert before contributing. I am only showing these commands here because you will use them while contributing.</p><p>For learning Git and GitHub properly, I recommend checking out the resources which i have shared at the end of this Blog</p><p><strong>Create the Pull Request</strong></p><p>Now go to your forked repository on GitHub. You should usually see an option to compare your branch with the original repository.</p><p>Click on: `<em>Compare &amp; pull request</em>`, GitHub will then take you to the Pull Request page.</p><p>And now comes a very important part.</p><p><strong>Write a Good PR Description</strong></p><p>Your PR description. Please don’t treat this like some boring form that you need to fill because GitHub asks you to. A good PR description makes the maintainer’s job much easier.</p><p>Imagine you are the maintainer. You open a PR from someone you don’t know. What would you want to know?</p><p>Probably:</p><blockquote>What issue is this solving?<br>What was causing the problem?<br>What did the contributor change?<br>How did they test it?<br>Does the issue actually get fixed now?<br>Are there screenshots or outputs showing the result?</blockquote><p>Your PR description should answer these things. Don’t just write: <em>“Fixed the bug.” </em>That tells the maintainer almost nothing. Instead, explain what you found and what you changed.</p><p>For example:</p><p>## What was the issue?</p><p>Brief explanation of the problem.</p><p>## What did I change?</p><p>Explain the implementation in simple words.</p><p>## How did I test it?</p><p>Mention the tests or demo you ran.</p><p>## Results</p><p>Show the output before and after the change.</p><p>## Related Issue</p><p>Link the issue here.</p><p>## Add Screenshots or Evidence</p><p>Remember the screenshots you took when you reproduced the issue? This is where they can become useful. If the issue has a visible output, error or visualization, show it using screenshots</p><p>This gives the maintainer quick evidence that you actually tested your solution. It can also make the review much easier because they don’t have to reproduce everything just to understand what changed.</p><p>## Mention the Issue</p><p>Make sure your PR clearly references the issue you worked on. This helps GitHub connect the PR to the issue and can also automatically close the issue when the PR is merged, depending on the project’s setup. Always check what the project prefers.</p><p>## AI Disclosure</p><p>Some projects may ask contributors to disclose whether AI was used while making the contribution. If the project asks for it, be honest about your AI usage. You can mention what tools you used and how you used them.</p><p>Don’t hide AI usage when the project specifically asks you to disclose it.</p><p>## Before You Click Submit</p><p>Read your PR description one more time. Ask yourself: <em>Can a maintainer understand what I changed without asking me basic questions?</em></p><p>For example → My PR’s which recently Got Merged look at its Description</p><p><a href="https://github.com/fury-gl/fury/pull/1359"><strong>Fury-PR-1359 </strong></a><strong><br></strong><a href="https://github.com/holoviz/datashader/pull/1547"><strong>Datashader-PR-1547</strong></a></p><blockquote>Did I explain how I tested it?<br>Did I provide evidence where useful?<br>Did I link the correct issue?<br>Did I mention anything the project specifically asked contributors to include?</blockquote><p>If everything looks good, submit the PR.</p><h4>Step 7: What to Do After Opening Your PR</h4><p>So your PR is finally submitted.Now what? <strong>Don’t panic. 😂</strong></p><p>The first thing I want you to understand is that maintainers are usually busy with their own work. They may not review your PR immediately. Sometimes it can take days. Sometimes it can take longer. So please don’t keep checking your PR every few minutes.</p><p>You don’t need to sit on GitHub all day waiting for a reply. You will normally get a notification when someone comments on your PR or starts a discussion.</p><p><strong>Go do something else. Work on another issue. Learn something new. Build a project. Study. Whatever you want.</strong></p><p>Just be patient.</p><p><strong>Don’t Keep Tagging Maintainers</strong></p><p>This is something I really want beginners to understand.</p><p><strong><em>Stop constantly tagging maintainers or mentors asking them to review your PR.</em></strong></p><p>They are already busy. You don’t need to keep saying: <em>“@maintainer please review my PR” </em>every few hours. If the project has a proper process for requesting reviews, follow that. Otherwise, give them some time. And please don’t take a slow review personally. The maintainer not replying immediately does not mean they don’t care about your contribution.</p><p><strong>Don’t Message People at the Wrong Time</strong></p><p>This is also something I learned from being part of open source communities. Try to understand when people are active. For example, if someone is not normally active on weekends, don’t keep sending messages and expecting an immediate reply. Your message can simply get buried under other conversations by the time they return. You don’t want to spam someone just because you are excited about your PR.</p><p><em>Be respectful of their time.</em></p><p><strong>When a Maintainer Gives You Feedback</strong></p><p>Now suppose a maintainer finally reviews your PR. They may say:</p><blockquote>“Please change this.”<br>“This implementation will not work here.”<br>“Can you add a test for this?”</blockquote><p>Or maybe they completely disagree with your approach. That’s okay. <strong>Don’t get defensive</strong>. Ask why. Try to understand their reasoning. Sometimes the maintainer knows something about the codebase that you didn’t know yet. This is one of the biggest advantages of contributing to open source.</p><p>You are not only contributing code. You are learning from people who have been working on the project for much longer than you. And sometimes one small review comment can teach you something that an entire tutorial could not.</p><p><strong>Your PR Can Be Rejected</strong></p><p>This is important. Your PR can be rejected. It can be closed. Your implementation can be completely wrong. It can happen. It happened to me. And honestly, it feels bad.</p><p>But don’t think:<em> “My PR got closed, so I’m bad at open source.” </em>Instead ask: <em>“Why did they reject it?”</em></p><p>Understand the reason. Learn what you did wrong. And carry that lesson into the next issue.</p><p>My first rejected PR with FURY is actually one of the reasons my current workflow is so different from the way I worked when I started. So don’t run away from rejection. <strong><em>Learn from it.</em></strong></p><p><strong>Talk to People</strong></p><p>One of the best parts of open source is that you don’t have to do everything alone. Talk to other contributors. <em>Join the project’s Discord. Join their forums. Read discussions. </em>Ask questions when you genuinely don’t understand something.</p><p>You don’t need to message people just for the sake of messaging them. Just be involved in the community. Over time, you start recognizing people. People start recognizing you. You learn how the community works. And you build genuine connections. That is something you don’t get from simply making PRs.</p><p><strong>Build Something With the ORG</strong></p><p>This is something I personally really enjoy doing. Don’t only fix issues. Try building something using the organization or its libraries. For example, when I was working with FURY, I started creating my own visualizations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k0Wml2T_-R-zMjUDTNQvlQ.png" /><figcaption>I Created Math Attractors Using Holoviz</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ojgEVLvPlC1slBDfxVsrHw.png" /><figcaption>I tried to Create Brain Visualization Using Fury and other Supporting Libraries</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*m9QwCMajhSljc6WlJSb7sA.png" /><figcaption>I wanted to Create one Virus Visualization but Failed 🥲</figcaption></figure><p><strong>Build something interesting. Experiment. Then share it with the community.</strong></p><p>You can showcase it in Discord, forums or whatever community space the project uses. People can see what you are building. You learn more about the project. And you become much more familiar with the codebase. For me, this made open source much more fun.</p><p>It stopped feeling like:</p><blockquote>“<strong>I need to solve issues because I am preparing for GSoC.</strong>” and started feeling like: “<strong>I actually want to build things with this project.</strong>”</blockquote><p>And honestly, that is the point where I started enjoying open source the most.</p><h3>A Few Final Words</h3><p>So, this is what I have learned so far. It has only been around 2–3 months, but honestly, open source has already changed the way I look at coding.</p><p>I have worked with codebases that I had never seen before.<br>I have talked to people from different places.<br>I have made mistakes.<br>I have had PRs closed.<br>I have learned things that I probably would not have learned by just working on college projects.<br>And I am still learning every single day.</p><p>I don’t have everything figured out.<br>I am still preparing for GSoC 2027, so this is only a small part of my journey. But I wanted to share this because I know how confusing the beginning can be. There are so many things that nobody tells you until you actually experience them.</p><p>So hopefully, something from my experience helps you when you start your own journey.</p><p>And one last thing… <em>Don’t be scared of open source. The beginning can feel confusing. You will make mistakes. You will get stuck. You might even get a PR rejected. That’s okay. Keep going. Once you get a grip on it, you will understand why so many people love it. </em><strong>Open source is genuinely fun.</strong></p><h4>This is Part 1 of my journey. I’ll share Part 2 after the GSoC 2027 cycle and talk about what happens next.</h4><h3>Some Resources That Might Help You</h3><p>Here are some resources which helped me during my open source and GSoC preparation. I am adding them here so you don’t have to search for everything from scratch.</p><h4>🎥 GSoC Journey &amp; Selection</h4><p>This video explains <a href="https://medium.com/u/f5ab4f93203c"><strong>Vrund Raval</strong></a> GSoC journey, how he got selected and what he did throughout the process. NGL guys Amazing Video do Check-it-OUT</p><p><a href="https://youtu.be/tPk6lMJDy_A?si=Gg2YSbB237zm6Qy8">CLICK ME</a></p><h4>🎥 Getting Started With Open Source</h4><p>If you want a small video tutorial on how to get started with open source, you can check this one.</p><p><a href="https://youtu.be/2do4WZ0e8UU?si=UsmfPYuS8z3xDKk4">CLICK ME</a></p><h4>💻 Learn Git &amp; GitHub</h4><p><strong><em>A Hacker’s Guide to Git</em> <br></strong>If you want to go deeper into Git and understand how it actually works, check out this website.<br><em>Sorry i could not upload Link because of Medium’s Policy</em></p><h4>🧩 Understand a Codebase Better</h4><p><strong><em>GitDiagram<br></em></strong>This can help you get a visual architecture of a GitHub repository, which can be very useful when you are trying to understand a new codebase.<br><em>Sorry i could not upload Link because of Medium’s Policy</em></p><p><strong>Gitingest<br></strong>Another useful tool for getting context from a repository and making codebase analysis easier.<br><em>Sorry i could not upload Link because of Medium’s Policy</em></p><h4>🔎 Find the Right GSoC Organizations</h4><p><strong><em>GSoC Organizations</em><br></strong>This website allows you to filter organizations based on things like the years they participated in GSoC and the programming languages you are familiar with.<br><em>Sorry i could not upload Link because of Medium’s Policy</em></p><h4>🕵️ Check Repository Competition</h4><p><strong><em>GSoC Spy</em><br></strong>This is a tool you can use to look at a repository and get an idea of whether the competition around that project is high or low.<br><em>Sorry i could not upload Link because of Medium’s Policy</em></p><h4>I will keep adding more useful resources here as I find them.</h4><h3>One Last Thing ❤️</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hoPOQhSUY1qy_l9ozzV1RQ.png" /><figcaption>DO IT 🤧</figcaption></figure><p>Guys, if you found this blog useful, please do support me.</p><p>A small <strong>like, follow or upvote</strong> really helps and would be highly appreciated.</p><p><strong>My-GitHub</strong>: <a href="https://github.com/AaryanRS">Click ME</a><br><strong>My-Instagram</strong>: <a href="https://www.instagram.com/shelar_1arynx/">Click ME</a></p><p><strong>Thank you for reading this far. ❤️</strong></p><h3>See you in Part 2.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H69-8q-7FzIWCYvzq5IdOA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a4915e9ce84" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>