Mastering Coding Challenges

"Vibe Coding !== Low Quality Work: a guide to responsible AI-assisted dev" ✍️ My latest free article: https://lnkd.in/gjMdjMWV The allure of "vibe coding" – using AI to "move faster and break even more things" – is strong. AI-assisted development is undeniably transformative, lowering barriers and boosting productivity. But speed without quality is a dangerous trap. Relying uncritically on AI-generated code can lead to brittle "house of cards" systems, amplify tech debt exponentially, and introduce subtle security flaws. Volume ≠ Quality. A helpful mental model I discuss (excellently illustrated by Forrest Brazeal) is treating AI like a "very eager junior developer." It needs guidance, review, and refinement from experienced hands. You wouldn't let a junior ship unreviewed code, right? So how do we harness AI's power responsibly? I've outlined a field guide with practical rules: ✅ Always review: Treat AI output like a PR from a new hire. ✅ Refactor & test: Inject engineering wisdom – clean up, handle edge cases, test thoroughly. ✅ Maintain standards: Ensure AI code meets your team's style, architecture, and quality bar. ✅ Human-led design: Use AI for implementation grunt work, not fundamental architecture decisions. The goal isn't to reject vibe coding, but to integrate it with discipline. Let's use AI to augment our craft, pairing machine speed with human judgment. #softwareengineering #programming #ai

Today, I witnessed my team lead interviewing a Full-Stack Web Developer with 2 years of experience, and I observed some interesting insights. The interview started with basic technical questions, which the candidate answered well. Then, my team lead gave him a coding task: 👉 "Write a function that removes duplicate values from a nested array while preserving its structure (PHP)." The candidate struggled and couldn’t solve it. So, my lead gave him another task: 👉 "Write a function that groups an array of associative arrays based on a specific key." Again, he couldn’t solve it. At this point, he admitted: "I don’t always have syntax and logic rules memorized, as I usually rely on resources like Stack Overflow and ChatGPT. Could you assign me a real-world task instead?" Here,I decided to step in. Since I was working on WooCommerce project, I gave him this challenge: 💡 "Implement a functionality where a logged-in user gets a 15% discount if they place two orders in a single day." We allowed him to use Google, ChatGPT, or any other resources. To our surprise, within 1.5 hour, he understood WooCommerce functionality, analyzed the existing code, and successfully implemented the feature. ✨ We ended up hiring him! ✨ Key Takeaway Many traditional interview techniques overemphasize logical puzzles and syntax-heavy questions, yet modern developers approach problem-solving differently. Rather than memorizing solutions, they adapt, learn, and implement on the spot using the tools and resources available to them. 💡 Instead of testing how well candidates remember syntax, we should focus on how effectively they apply problem-solving skills to practical challenges. What’s your take on this? Let’s discuss in the comments! 👇 #HiringTechTalent #TechCommunity #WhatDoYouThink

I solved less than 300 LeetCode questions but still made it to Google! When I started problem-solving, I thought I had to grind through hundreds or even thousands of problems to improve. But over time, I realized: ✅ It’s not about the number of problems you solve. ✅ It’s about depth of understanding and recognizing patterns. ✅ Solving the right set of problems makes all the difference. Here are 20 LeetCode questions that can significantly boost problem-solving skills: 1️⃣ Merge Intervals 2️⃣ Koko Eating Bananas 3️⃣ Search in Rotated Sorted Array 4️⃣ Detect a Cycle in Linked List 5️⃣ Word Search II 6️⃣ Gas Station 7️⃣ Sliding Window Maximum 8️⃣ Coin Change 9️⃣ Word Break 🔟 Edit Distance 1️⃣1️⃣ Trapping Rainwater 1️⃣2️⃣ Largest Rectangle in a Histogram 1️⃣3️⃣ Rod Cutting 1️⃣4️⃣ Binary Tree Maximum Path Sum 1️⃣5️⃣ Number of Distinct Islands 1️⃣6️⃣ Rotten Oranges 1️⃣7️⃣ Course Schedule II 1️⃣8️⃣ Pacific Atlantic Water Flow 1️⃣9️⃣ Cheapest Flights Within K Stops 2️⃣0️⃣ Min Cost to Connect All Points These problems cover Greedy, DP, Graphs, Binary Search, Sliding Window, Trees, and more—helping to build a strong problem-solving mindset rather than just memorizing solutions. 💡 What I Learned Along the Way: 🔹 Quality over quantity—solving fewer problems deeply is better than rushing through many. 🔹 Pattern recognition matters—many problems share similar core ideas. 🔹 Revisiting and optimizing solutions—helps reinforce concepts and improve efficiency. If you’re preparing for interviews, don’t focus on hitting a high problem count. Focus on understanding concepts, thinking deeply, and solving strategically. Of course, sometimes we do need to practice more to get better. The key is to identify what works best for you—some may need more practice, while others improve by focusing on fewer problems but solving them deeply. #LeetCode #ProblemSolving #Google #CodingInterview #DSA #Tech #Growth

In the last 15 years, I have interviewed 800+ Software Engineers across Google, Paytm, Amazon & various startups. Here are the most actionable tips I can give you on how to approach  solving coding problems in Interviews  (My DMs are always flooded with this particular question) 1. Use a Heap for K Elements      - When finding the top K largest or smallest elements, heaps are your best tool.      - They efficiently handle priority-based problems with O(log K) operations.      - Example: Find the 3 largest numbers in an array.   2. Binary Search or Two Pointers for Sorted Inputs      - Sorted arrays often point to Binary Search or Two Pointer techniques.      - These methods drastically reduce time complexity to O(log n) or O(n).      - Example: Find two numbers in a sorted array that add up to a target.   3. Backtracking    - Use Backtracking to explore all combinations or permutations.      - They’re great for generating subsets or solving puzzles.      - Example: Generate all possible subsets of a given set.   4. BFS or DFS for Trees and Graphs      - Trees and graphs are often solved using BFS for shortest paths or DFS for traversals.      - BFS is best for level-order traversal, while DFS is useful for exploring paths.      - Example: Find the shortest path in a graph.   5. Convert Recursion to Iteration with a Stack      - Recursive algorithms can be converted to iterative ones using a stack.      - This approach provides more control over memory and avoids stack overflow.      - Example: Iterative in-order traversal of a binary tree.   6. Optimize Arrays with HashMaps or Sorting      - Replace nested loops with HashMaps for O(n) solutions or sorting for O(n log n).      - HashMaps are perfect for lookups, while sorting simplifies comparisons.      - Example: Find duplicates in an array.   7. Use Dynamic Programming for Optimization Problems      - DP breaks problems into smaller overlapping sub-problems for optimization.      - It's often used for maximization, minimization, or counting paths.      - Example: Solve the 0/1 knapsack problem.   8. HashMap or Trie for Common Substrings      - Use HashMaps or Tries for substring searches and prefix matching.      - They efficiently handle string patterns and reduce redundant checks.      - Example: Find the longest common prefix among multiple strings.   9. Trie for String Search and Manipulation      - Tries store strings in a tree-like structure, enabling fast lookups.      - They’re ideal for autocomplete or spell-check features.      - Example: Implement an autocomplete system.   10. Fast and Slow Pointers for Linked Lists      - Use two pointers moving at different speeds to detect cycles or find midpoints.      - This approach avoids extra memory usage and works in O(n) time.      - Example: Detect if a linked list has a loop.   💡 Save this for your next interview prep!

In the last 1+ year while working at Google, I've come across 50+ candidates in coding interviews for the SDE-1 role and I always see these 3 kinds of people: → The ones who panic Their mind goes blank the moment a new problem lands in front of them. They know the basics, but nerves take over. → The ones who guess They keep throwing random solutions, hoping something sticks. They’ve practiced, but pattern recognition is missing. → The ones who spot the pattern in 2 minutes They break the problem down calmly, map it to something they’ve seen before, and explain their thinking step by step. Guess who gets the offer? The difference isn’t “IQ” or “talent.” It’s practice, pattern recognition, and learning with the right approach. If you want to stand out, never memorize solutions. Learn to spot the patterns. I can tell you from my experience that If you want to crack PBCs, strong DSA and clear pattern recognition are non-negotiable. One of the smartest ways to build that is by Learning from this amazing DSA pattern sheet, which I love to recommend to people. Check it out: https://shorturl.at/BpCGX This will help you: ✅ Identify key patterns and when to use them ✅ Spot clues that map to approaches (Sliding Window? DP? Backtracking?) ✅ Practice 5–6 handpicked Leetcode problems per pattern ✅ Cover 250–300 essential questions ✅ Track progress and customize your prep Stop collecting problem sheets. Start pattern training.

The Agentic AI shift demands a very different stack — not just in terms of tools, but in mindset, workflows, and design principles. Here’s what you really need to know: 𝟭. 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗧𝗵𝗶𝗻𝗸𝗶𝗻𝗴 𝗦𝘁𝗮𝗿𝘁𝘀 𝘄𝗶𝘁𝗵 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗴𝗻 Most people confuse AI agents with smart LLM wrappers. But true agents have:  • Goals — not just tasks  • Context management — not just one-off memory  • Autonomy & adaptability — not just API chains  • Multi-agent coordination — not just sequential steps The rise of protocols like MCP (Model Context Protocol) and A2A (Agent-to-Agent) show where we’re headed: agents talking, negotiating, and collaborating. 𝟮. 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 𝗜𝘀𝗻’𝘁 𝗗𝗲𝗮𝗱 — 𝗜𝘁’𝘀 𝗘𝘃𝗼𝗹𝘃𝗶𝗻𝗴 To build agents, you still need the fundamentals:  • Languages: Python, JS, TypeScript, Shell  • Tooling: APIs, async execution, file handling, scraping But now layered with:  • Prompt engineering → Chain-of-thought → Reflexion loops  • Goal decomposition + decision policies  • Tool use + action planning + retry logic  • Prompting is no longer a skill. It’s a system behavior. 𝟯. 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸𝘀 𝗔𝗿𝗲 𝗘𝘅𝗽𝗹𝗼𝗱𝗶𝗻𝗴 — 𝗕𝘂𝘁 𝗨𝘀𝗲 𝗧𝗵𝗲𝗺 𝗪𝗶𝘀𝗲𝗹𝘆  • Depending on your use case, you’ll want to explore:  • LangGraph and LangChain for flexible agent flows  • AutoGen and CrewAI for research-style agents  • Flowise for visual low-code orchestrations  • Superagent, Semantic Kernel, and others for modular design Each framework has strengths and trade-offs — choosing one requires understanding your orchestration, memory, and collaboration needs. 𝟰. 𝗢𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻 𝗶𝘀 𝘁𝗵𝗲 𝗛𝗲𝗮𝗿𝘁 𝗼𝗳 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗦𝘆𝘀𝘁𝗲𝗺𝘀 Forget linear pipelines. Agent systems require:  • DAG-based flows  • Event-driven triggers  • Conditional loops  • Guardrails and validations The goal is not to run code — it’s to simulate reasoning and adaptation over time. 𝟱. 𝗠𝗲𝗺𝗼𝗿𝘆 𝗜𝘀𝗻’𝘁 𝗝𝘂𝘀𝘁 𝗮 𝗩𝗲𝗰𝘁𝗼𝗿 𝗦𝘁𝗼𝗿𝗲 Real agents need:  • Short-term memory (context windows)  • Long-term memory (episodic retrieval)  • Dynamic knowledge integration (RAG + vector DBs)  • Technologies like Weaviate, Chroma, Pinecone, and FAISS make this possible — but only when paired with intelligent memory policies and indexing strategies. 𝟲. 𝗢𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆, 𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗶𝗼𝗻 & 𝗚𝗼𝘃𝗲𝗿𝗻𝗮𝗻𝗰𝗲 𝗮𝗿𝗲 𝗡𝗼𝗻-𝗡𝗲𝗴𝗼𝘁𝗶𝗮𝗯𝗹𝗲 As agents gain autonomy, we need:  • Tracing & logging (LangSmith, OpenTelemetry)  • Human-in-the-loop evaluation  • Auto-evaluation loops  • Security: prompt injection defense, API key mgmt, RBAC, red teaming You can't deploy what you can't monitor.  And you shouldn't deploy what you can’t secure. The next generation of AI builders won't just prompt LLMs — they'll design intelligent systems. Agentic AI blends programming, reasoning, memory, orchestration, and governance into one integrated discipline. …it’s time to think agentically.

Most people don’t fail in DSA because it’s hard. They fail because they try to learn everything instead of learning the right patterns. If you’re a fresher preparing for coding interviews, stop collecting questions. Start mastering patterns. Here’s the exact roadmap I recommend 👇 1️⃣ Arrays Core patterns you must know: • Two Pointers • Sliding Window (fixed and variable) • Prefix Sum • Kadane’s Algorithm • Hashing / Frequency Map • Sorting + Greedy • Cyclic Sort • Binary Search 2️⃣ Linked Lists Core patterns: • Fast & Slow Pointer • Dummy Node • Reversal (entire list / k-group) • Merge Lists • Pointer Rewiring 3️⃣ Stack & Queue Core patterns: • Monotonic Stack • Monotonic Queue • Stack for Previous / Next Greater • Sliding Window + Deque 4️⃣ Trees & Graphs Core patterns: • DFS (pre / in / post order) • BFS (level order) • Recursion • Backtracking on Trees • Dijkstra • Topological Sort • Union Find 5️⃣ Advanced Patterns • Binary Search on Answer • Greedy • Dynamic Programming ◦ 0/1 Knapsack ◦ Unbounded Knapsack ◦ DP on Strings • Heap (Top K, Merge K) • Bit Manipulation You don’t need 1000 problems. You need clarity on these patterns. Once you understand the pattern, 10 different questions start looking the same. That’s when preparation becomes smart. If you’re preparing for placements or switching jobs, save this post and follow for more such content ❤️

If I had to start from zero and my goal was to get as strong in DSA as possible in 2025, this is everything I’d do: 1. The only pre-requisite is knowing one language to a decent level - any language is fine. 2. If you're an absolute beginner, you can start with easy problems. If you can't solve that one, pick easier. Still not, pick even easier. You can find problems like, given a and b, find a + b. So I am sure you can find a problem you'll be able to solve. 3. Solve 10-20 easy problems. In the beginning, it's useful to get the confidence, that you belong and it's not some extremely difficult thing you're trying. 4. Start right away. Don't fall into the trap of finding the best resource. Pick any one which is good enough for the topic in hand and follow that. 5. Pick a topic, read the theory and get to problem solving. Solve topic wise problems when learning a new topic. When doing overall practice, solve random problems, and never look at topic beforehand as often figuring out what needs to be used is the main part in itself. 6. If you are trying to solve a problem, you get stuck. Don't look at the solution immediately. Think, struggle, brainstorm potential ideas. This is the stage where most of the learning and improvement happens. Look at the solution at least 20-30 minutes of brainstorming. Try to look at the solution incrementally as in look at some part of the solution as a hint and try to solve from there. 7. Proof Matters a lot. Why the solution is correct is very important and arguably often more important than the solution itself. Getting the proof helps you in more fundamental understanding which is key for solving new problems. 8. The more fundamentally you understand a concept, the more chances of you solving a problem using that. 9. Most of the websites have problem difficulties mentioned. When you feel comfortable at a level, move towards the higher-difficulty problems. 10. Pick problems that are slightly above your level. Solving too many easy ones after a point isn't helpful and neither is so hard where you have literally no clue. 11. While solving problems, tracking the time taken for a problem is also a good idea. Being able to solve a problem in 2 hours and 20 minutes are very different things. Don't worry much about this when learning a very new topic or in the beginning. 12. Goal while solving the problems is understanding the concept well. Always remember this. Don't fall in the trap of increasing the solved problem count without understanding it. 13. Take part in live contests, contests are a good way to track your improvement. Follow me for similar educational posts. Like this if you found it useful. Lemme know if I should elaborate and share more thoughts on any of the above points.

Cursor recently shipped Composer, its agentic coding model, and shared that the agent can be ~4× faster! We worked with the Cursor team, particularly Lee Robinson, to understand how the system is put together, and what drives the speed. A coding agent is a system that can take a task, explore a repo, edit multiple files, and iterate until the build and tests pass. Inside Cursor, a router first picks a suitable coding model (including Composer) to handle the request. The system then starts a loop: retrieve the most relevant code (context retrieval), use tools to open and edit files, and run commands in a sandbox. Once the tests pass, the task is complete. Cursor uses three key techniques to keep this loop fast: 1. Mixture-of-Expert (MoE): A sparse MoE architecture activates only a subset of model weights per token. 2. Speculative decoding: a smaller model drafts multiple tokens at once, then a larger model verifies them in parallel to reduce latency. 3. Context compaction: summarize older steps and keep only the active working set so the prompt stays relevant and short as iterations continue. Full newsletter here: https://lnkd.in/g7_gsszQ

The Right Way to Solve a DSA Problem! I’ve been solving at least one DSA problem on LeetCode almost every day for more than a year... hardly a day goes by when I don’t. And during this time, I realized there’s one common mistake that almost everyone (including me) makes. You start solving a problem. You get stuck. You check the first hint... then the second... then the discussion section. Still can’t figure it out. Finally, you open the solution and boom, it looks so simple. You copy it, submit it, feel great for a moment… and move on. But here’s the problem a month later, you see the same question again and get stuck in the exact same place. You vaguely remember the approach but can’t recall the logic. You open the solution again, try to memorize it again… and the same cycle repeats. Welcome to the DSA Trap... where you think you understood the problem, but can’t solve it on your own. 💡 How to Break Out of it! Start by reading the problem statement properly... understand what’s being asked and what the expected output is. Then, give it time. Think through multiple approaches and always begin with the brute force method. It builds confidence and ensures you’ve understood the problem correctly. Write pseudocode before you code. Pseudocode helps you visualize the logic and exposes the pattern behind the solution. If you still can’t solve it, look at others’ solutions, but don’t just memorize. Understand why the solution works. If it’s still unclear, watch a tutorial (I personally recommend this youtube channel @codestorywithMIK). After you understand the concept, immediately solve 2-3 similar problems. This is how you lock the pattern into your brain. One more practical tip: keep an Excel/Notion sheet or a notebook of problems you couldn’t solve on the first try. Revisit it weekly. Once you can solve a problem on your own, remove it. Over time, the list shrinks and your confidence grows. ✨ Hope this adds some value to your DSA journey! #DSA #ProblemSolving #Coding #LeetCode #Learning #Consistency #Programming