Devesh Shukla’s Post

Solved the classic Reverse Linked List problem on LeetCode today. Approach used: Iterative pointer manipulation. Key idea: Maintain three pointers — prev, curr, and next. Algorithm flow: Store the next node (next = curr.next) Reverse the link (curr.next = prev) Move pointers forward (prev = curr, curr = next) Time Complexity: O(n) Space Complexity: O(1) It’s a simple problem conceptually, but mastering pointer manipulation is essential for understanding linked list internals and many advanced data structure problems. Consistently practicing these fundamentals strengthens problem-solving intuition and prepares you for more complex algorithmic challenges. #leetcode #datastructures #algorithms #javascript #linkedlist #problemSolving #codingPractice

Stop Shifting Elements. Use Two Pointers Instead ⚡📦 Solved LeetCode 283 (Move Zeroes) today. Problem 🔍 Move all 0s to the end while maintaining the order of non-zero elements. Initial thought 🧠 Shift elements or use extra array. Works, but increases time or space complexity. Better approach 🚀 Use two pointers: 1️⃣ One pointer tracks position for next non-zero 2️⃣ Traverse array 3️⃣ Swap non-zero elements forward Mental model 🧩 Partition the array: Left → non-zero zone Right → zero zone Interview takeaway 🎯 When rearranging elements in-place while preserving order, think two pointers + partitioning. Practical insight 💡 Avoid unnecessary swaps. Only move when needed to keep operations minimal. Time: O(n) Space: O(1) #DSA #LeetCode #Algorithms #TwoPointers #JavaScript #CodingInterview #InterviewPrep #ArrayProblems

Spent three hours debugging why my web scraper was failing randomly... Turns out the target site was loading content with a 2-second delay, but only sometimes. Classic intermittent bug. Fixed it by adding proper wait conditions in Playwright instead of hardcoded sleeps. Now it waits for the actual element to appear, not just a fixed time. The scraper went from 70% success rate to 99.8% overnight. This is why I always tell people: async loading breaks everything if you're not careful. Modern websites are not your friend when building automation. What's the weirdest intermittent bug you've had to track down? --- Want to automate your workflows or build AI-powered systems for your business? DM me — I help teams ship automation that actually works. #BuildInPublic #WebScraping #Playwright #DevLife #Automation #Python #Debugging #SideProject

🚀 Efficiency Wins: Why Two Pointers Beat Nested Loops 👈👉 Today’s deep dive into the Two Pointer Technique was a perfect reminder that "thinking before coding" is a developer's best skill. Here is how I optimized my approach to solving Two Sum II: 🛠️ Key Technical Takeaways Kill Redundant Flags: I initially used a while(!flag) setup. I quickly realized this was extra baggage—using while (left < right) is the cleaner, more idiomatic "guardrail" that naturally prevents infinite loops. The 1-Indexed Challenge: The problem requires a 1-indexed return. I learned to handle the logic in 0-index but adjust the final output by adding 1 to avoid off-by-one errors. The "Not Found" Safety Net: If no pair exists, returning [-1, -1] is the standard way to signal "not found." Without the left < right condition, the code could crash or loop forever if the target isn't present. ⚡ The Efficiency Edge O(n) vs O(n²): Instead of checking every possible pair (slow), we use two "bookmarks" and find the answer in a single pass. Space Efficiency: By using only two variables, the space complexity stays O(1), no matter how massive the dataset. 🏆 The Milestone Successfully solved Two Sum II using a clean, linear approach! Moving from brute-force to optimized logic feels like a massive level-up. 💻 Code Snippet: function two_pointers(input, target){ let left = 0 let right = input.length - 1 while(left < right){ const currentSum = input[left] + input[right] if(currentSum === target){ return [left + 1, right + 1] } else if(currentSum > target){ right -= 1 } else{ left += 1 } } return [-1, -1] } let input = [2, 7, 11, 15] let target = 9 console.log(two_pointers(input, target)) #DataStructures #Algorithms #LeetCode #CodingInterviews #CleanCode #JavaScript #SoftwareEngineering #ProblemSolving

𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁 𝘁𝗲𝗮𝗺𝘀 𝘀𝗵𝗼𝘂𝗹𝗱𝗻’𝘁 𝘁𝗮𝗸𝗲 𝟭,𝟬𝟬𝟬+ 𝗹𝗶𝗻𝗲𝘀 𝗼𝗳 𝗣𝘆𝘁𝗵𝗼𝗻. But right now, it does. You write config. Debug connections. Rewrite boilerplate. Repeat for days. We built Agno Builder to fix that. 👉 Drag agents onto a canvas. 👉 Connect them into teams. 👉 Test with real chat. 👉 Export production ready code and pass it to devs Today we are shipping v1.3.0. Here’s what’s new 👉 Sign in with Google, GitHub, or Apple 👉 3 pricing tiers (free tier included, no credit card) 👉 120+ tools across 12 categories 👉 DB persistence and chat history 👉 10+ templates with coordinator + sub-agents The free tier gives you 1 workflow, 3 agents, and 5 messages/day. 𝗘𝗻𝗼𝘂𝗴𝗵 𝘁𝗼 𝗯𝘂𝗶𝗹𝗱 𝘀𝗼𝗺𝗲𝘁𝗵𝗶𝗻𝗴 𝗿𝗲𝗮𝗹 𝗯𝗲𝗳𝗼𝗿𝗲 𝘆𝗼𝘂 𝘀𝗽𝗲𝗻𝗱 𝗮 𝗱𝗼𝗹𝗹𝗮𝗿. Watch the full 2-min walkthrough below. What’s the first agent workflow you would build? agnobuilder[.]com #AIAgents #BuildInPublic #AgnoBuilder #Python #NoCode

Debugging at small scale is annoying; Debugging at scale is expensive. When a frontend codebase grows, abstraction doesn’t just add structure — it adds distance between cause and effect. - A state update triggers an effect. - That effect updates derived state. - That derived state triggers another effect. - A memoized function masks the real dependency. Now a simple bug requires tracing a chain of indirection. - The issue isn’t React. - The issue isn’t hooks. - The issue is layered runtime abstraction. At scale, debugging complexity grows faster than feature complexity. You don’t just ask: “Why is this value wrong?” You ask: - “Which lifecycle triggered this?” - “Which dependency changed?” - “Why did this re-render twice?” - “Which abstraction is hiding the real data flow?” Every layer of indirection adds mental hops; And mental hops slow teams down. This is where architectural philosophy matters. In compile-first systems like Svelte, the dependency graph is explicit. - State is declared with $state(). - Derived relationships use $derived(). - Side effects are isolated with $effect(). The compiler understands the flow. That reduces hidden coupling and makes debugging closer to tracing plain JavaScript rather than tracing a rendering engine. When systems scale, clarity becomes more valuable than flexibility. Tomorrow, we move into something foundational: Reactivity — explained without magic words. No mysticism. No framework folklore. Just a clear look at how data actually flows. #Svelte #Svelte5 #FrontendDevelopment #SoftwareArchitecture #ReactJS #WebEngineering #Maintainability #CompiledSpeed #SvelteWithSriman

Solved “Add Two Numbers” on LeetCode with an efficient approach using linked list traversal and carry handling. Key highlights: Used a dummy node to simplify list construction Handled different list lengths seamlessly Managed carry propagation correctly across nodes Achieved optimal time complexity O(max(n, m)) Performance: Runtime: 3 ms (faster than ~55%) Memory: 61.25 MB (better than ~79%) This problem reinforces how mastering fundamentals like linked lists and pointer manipulation is crucial for writing clean and scalable solutions. Consistent practice is the real edge. #leetcode #datastructures #algorithms #coding #javascript #problemSolving #softwareengineering

I've been using Claude Code for a few weeks now, and its "broken record" effect is the biggest productivity killer. There's nothing more frustrating than having to remind a CLI agent for the tenth time to use Tailwind, follow a specific naming convention, or run a specific test suite before pushing. The fix: CLAUDE.md It's an onboarding manual for your project's LLM. You run /init, and it creates a file in your root directory that Claude reads every time you start a session. I've started including three things in mine: 1) The Tech Stack, such as "We're on Next.js 15, using Vitest for unit tests." 2) A "Never Do This" list. Never use class components. Never use default exports. 3) Commands like "Run npm run lint and npm run test after every file change." #ClaudeCode #SoftwareEngineering #DeveloperExperience #AI

Day 64/100 – #100DaysOfLeetCode 🚀 🧩 Problem: LeetCode 189 – Rotate Array (Medium) 🧠 Approach: Use the array reversal technique. Reverse the entire array Reverse the first k elements Reverse the remaining elements This rotates the array in-place. 💻 Solution: class Solution:   def rotate(self, nums: List[int], k: int) -> None:     """     Do not return anything, modify nums in-place instead.     """     n = len(nums)     k = k % n             def reverse(l, r):       while l < r:         nums[l], nums[r] = nums[r], nums[l]         l += 1         r -= 1           reverse(0, n - 1)        reverse(0, k - 1)        reverse(k, n - 1) ⏱ Time | Space: O(n) | O(1) 📌 Key Takeaway: Reversal is a powerful in-place technique for solving array rotation problems efficiently. #leetcode #dsa #development #problemSolving #CodingChallenge