Mahim Haque’s Post

🚀 The Happy Path: The "Magic" of Deleting Code There is no cleaner code than the code that no longer exists. We often think "progress" means adding more: more features, more abstractions, more lines. But one of the most pleasant "wins" in a developer's day is finding a way to solve a problem by removing complexity. Replacing a custom, buggy function with a single built-in library call? Pure bliss. Deleting a 100-line workaround because a dependency finally updated? Chef’s kiss. 👨🍳 It’s lighter, it’s faster, and it’s one less thing for your future self to debug. What’s the most satisfying chunk of code you’ve ever been able to delete? Let’s hear your "deletion wins" in the comments! 👇 #TheHappyPath #SoftwareEngineering #CleanCode #ProgrammingLife #Python #Django

RAG without using any framework: The Upgrade 🛠️ I recently ditched LangChain to build a RAG engine from scratch. The goal was total control over the pipeline. In January 2026, I made the initial prototype. I just pushed a major update including Reranking and a Web UI via Streamlit. Tech Stack: ➡️ Python 3.12 + asyncio ➡️ Google Gemini 2.5 Flash ➡️ FAISS + FlashRank (ms-marco-TinyBERT-L-2-v2) ➡️ Streamlit & Docker Why manual ? By implementing the ingestion, chunking, and retrieval manually, I optimized the memory management (auto-summarization) and added local reranking without fighting against library abstractions. The result is a fast, async RAG app that I actually understand line-by-line. 🚧 Current Status & Roadmap: Next, I plan to make a fast offline RAG with more features added on top of the current ones. #RAG #Python #GenerativeAI #Streamlit #Docker #GoogleGemini #Reranking #MachineLearning #VectorSearch #asyncio

Python dependency management just hit 100mph. 🚀 Still waiting minutes for pip install to finish? It’s time to meet uv. Written in Rust by the Astral team (the creators of Ruff), uv is more than just a package manager—it’s a single binary that replaces: ✅ pip (but 10-100x faster) ✅ pyenv (manages Python versions for you) ✅ poetry/pipenv (handles lockfiles and virtualenvs) ✅ pipx (runs tools in isolated environments via uvx) Why I’m switching: Blazing Speed: It resolves dependencies almost instantly, even for massive projects. Zero-Config: No more juggling five different tools just to start a project. Universal Lockfiles: Reproducible builds that actually work across teams. If you haven’t tried uv yet, your CI/CD pipelines (and your patience) will thank you for making the switch. Have you made the jump to uv yet, or are you sticking with the classics? 👇 #Python #SoftwareEngineering #DeveloperTools #Rust #Astral #uv

I thought contributing to Streamlit meant 𝗳𝗶𝘅𝗶𝗻𝗴 𝘀𝗺𝗮𝗹𝗹 𝗨𝗜 𝗯𝘂𝗴𝘀. I didn’t expect to 𝗿𝗲𝘃𝗲𝗿𝘀𝗲-𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿 its entire architecture. While working on a component, I kept asking: “𝗪𝗵𝗲𝗿𝗲 𝗱𝗼𝗲𝘀 𝘁𝗵𝗶𝘀 𝗯𝘂𝘁𝘁𝗼𝗻 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗴𝗼?” I became so curious that I kept learning more and more about it 👇 User Python Code ↓ Elements API (button.py) ↓ DeltaGenerator ↓ Protobuf ↓ Runtime / Session Manager ↓ Tornado WebSocket ↓ React (TSX) ↓ Browser UI Unlike 𝗗𝗷𝗮𝗻𝗴𝗼 𝘁𝗲𝗺𝗽𝗹𝗮𝘁𝗲𝘀 or 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 𝗥𝗘𝗦𝗧 𝗔𝗣𝗜𝘀, Streamlit flows like this: 🧠 Python → Protobuf → WebSocket → React → Rerun Model Every click reruns the script. State lives in the session manager. UI updates happen through delta patches over a persistent WebSocket. That’s when it clicked, Streamlit isn’t just client–server. It’s reactive execution architecture, closer to 𝗥𝗲𝗮𝗰𝘁 + 𝗝𝘂𝗽𝘆𝘁𝗲𝗿 + 𝗲𝘃𝗲𝗻𝘁-𝗱𝗿𝗶𝘃𝗲𝗻 systems. The lesson? If a framework feels “𝘀𝗶𝗺𝗽𝗹𝗲,” it’s usually hiding something sophisticated. Don’t stop at using it - dissect it. Understanding the layers transforms you from a user into a builder. How do you usually break down a complex system to understand it completely? #CodingJourney #DeveloperCommunity #Streamlit #OpenSourceContributing

AI Web Designer that generates complete HTML websites directly inside a Python notebook and renders them. The demo is built with Mercury and shows how notebooks can go beyond experiments - the AI writes pure HTML, the page is previewed instantly, and the source code is visible side by side. Notebook code https://lnkd.in/dpA45rn9

Day 2/90: Variables That Refuse to Change (Literally) 🔒 In Rust, variables are immutable by default. Coming from Python where everything just... changes whenever, this is wild. let x = 5; x = 6; // ❌ NOPE. Compiler says no. Want to change a variable? You have to explicitly say so: let mut y = 5; // NOW you can change it y = 6; // ✅ Works! At first I was like "why is Rust making my life harder?" But then I realized something... In my data analysis work, I've had bugs where I accidentally overwrote a variable in a loop and spent hours debugging. In Rust? The compiler would've caught that immediately. It's like Rust is forcing me to think: "Does this NEED to change?" 99% of the time, it doesn't. The craziest part? SHADOWING. You can reuse variable names AND change their type: let spaces = "  ";    // string let spaces = spaces.len(); // now it's a number! This is different from `mut` because you're creating a NEW variable, not changing the old one. Mind = blown. Real talk: This felt annoying at first, but after getting a few compiler errors, I get it. The friction is intentional. It's teaching me to write better code. Coming from "move fast and break things" languages, Rust is more like "move deliberately and don't break anything." --- 💡 TL;DR: - Variables immutable by default (use `mut` to change) - Immutability = fewer bugs in production - Shadowing lets you reuse names and change types - The compiler's strictness is actually helpful - Day 2: Trust issues in code form ✅ 🔗 Code: https://lnkd.in/eKABvh2U #RustLang #LearnInPublic #100DaysOfCode #Programming #SoftwareEngineering Do you prefer immutable-by-default or mutable-by-default languages?

Switched a critical piece of business logic from a Node/Express setup to Django REST Framework this sprint. The difference in maintainability for complex tasks is striking. I find myself reaching for Python's clarity when dealing with heavy orchestration or integrating ML models—which we’re doing more of now with our AI-first push. Static typing clarity

I asked Claude Code to stop wasting my tokens. It told me to stop using it. I was converting Confluence pages to markdown by passing them through Claude Code. Page after page. Every conversion cost tokens - for something that's just a format change. So I asked Claude Code: you're spending too many tokens on this. What's the token-optimized way? Its answer: use Pandoc. This doesn't need me. I built a Python script. It calls the Confluence REST API, downloads the page, and runs Pandoc for the conversion. Zero tokens. But then 3 things broke: 1. Images were not getting downloaded in the .md file 2. Table formatting was not proper 3. Status labels and @mentions were not converting to markdown Multiple iterations later - the script now handles all of it. Pages convert to markdown without missing anything. Proper formatting. No token cost. The thing that stuck with me: I wasn't wasting tokens on hard problems. I was wasting them on mechanical tasks that a Python script handles better. If you're using Claude Code, Antigravity, Cursor, or any AI tool - try this before your next conversion. Ask yourself: does this need intelligence, or is it just a format change? If it's just format - write a script. Save the tokens for the work that actually needs thinking. Feel free to connect if you want to know more. Happy to help. #ClaudeCode #Python #Confluence #BuildInPublic #AITools

🚀 LeetCode Practice: Problem #145 – Binary Tree Postorder Traversal I recently solved LeetCode 145, a classic tree traversal problem that strengthens understanding of Depth-First Search (DFS) and recursion. 📌 Problem Statement Given the root of a binary tree, return the postorder traversal of its nodes’ values. Postorder Traversal Order: 👉 Left → Right → Root 🧠 Technique Used: Depth-First Search (Recursive Approach) Approach Explanation: If the current node is None, return. Recursively traverse the left subtree. Recursively traverse the right subtree. Visit (append) the root node value at the end. This traversal ensures that child nodes are processed before their parent node. Time Complexity: O(n) Space Complexity: O(h) (Where h is the height of the tree due to recursion stack) #LeetCode #Python #DSA #ValidAnagram #ProblemSolving #Algorithms #DataStructures #CodingPractice #100DaysOfCode #InterviewPreparation #SoftwareEngineering #DeveloperJourney #TechCommunity #LearningByDoing

A ~550-word AGENTS.md reduced agent runtime by 28.64% and token usage by 16.58% on SWE-bench Verified. The trick wasn’t more context — it was less ambiguity. I tested these ideas while refactoring agent docs for a production Python/FastMCP monorepo at NOS. What stuck with me: 𝗔𝗚𝗘𝗡𝗧𝗦.𝗺𝗱 𝘄𝗼𝗿𝗸𝘀 𝘄𝗵𝗲𝗻 𝗶𝘁’𝘀 𝗲𝘅𝗲𝗰𝘂𝘁𝗮𝗯𝗹𝗲 𝗼𝗻𝗯𝗼𝗮𝗿𝗱𝗶𝗻𝗴. Setup + test commands beat prose (Lulla et al.). 𝗔𝗚𝗘𝗡𝗧𝗦.𝗺𝗱 𝗶𝘀 𝗯𝗲𝗰𝗼𝗺𝗶𝗻𝗴 𝘁𝗵𝗲 𝗶𝗻𝘁𝗲𝗿𝗼𝗽𝗲𝗿𝗮𝗯𝗹𝗲 𝗱𝗲𝗳𝗮𝘂𝗹𝘁. 4,860 context files across GitHub; `.cursorrules` is basically legacy (Galster et al.). 𝗦𝗵𝗼𝗿𝘁 𝗯𝗲𝗮𝘁𝘀 𝗰𝗼𝗺𝗽𝗿𝗲𝗵𝗲𝗻𝘀𝗶𝘃𝗲. Most files are <500 words; medians cluster around ~335–535 words (Chatlatanagulchai et al.). 𝗧𝗲𝘀𝘁𝗶𝗻𝗴 𝗶𝗻𝘀𝘁𝗿𝘂𝗰𝘁𝗶𝗼𝗻𝘀 𝗮𝗿𝗲 𝘁𝗵𝗲 𝗵𝗶𝗴𝗵𝗲𝘀𝘁-𝘀𝗶𝗴𝗻𝗮𝗹 𝘀𝗲𝗰𝘁𝗶𝗼𝗻. They show up in ~75% of high-quality files. 𝗔𝘂𝘁𝗼-𝗴𝗲𝗻𝗲𝗿𝗮𝘁𝗲𝗱 𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝗰𝗮𝗻 𝗯𝗮𝗰𝗸𝗳𝗶𝗿𝗲. LLM-generated files dropped success by ~3% on average while raising cost >20% (Gloaguen et al.). 𝗙𝗶𝗹𝗲 𝗹𝗼𝗰𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻 𝗶𝘀 𝘄𝗵𝗲𝗿𝗲 𝗮𝗴𝗲𝗻𝘁𝘀 𝗳𝗮𝗶𝗹 𝗳𝗶𝗿𝘀𝘁. If they edit the wrong file, everything downstream collapses (ContextBench). What I did with this: one canonical AGENTS.md (~550 words, every snippet verified), CLAUDE.md + Copilot instructions as thin pointers, deleted `.cursorrules`, and 4 path-scoped instruction files that auto-inject context per folder. Takeaway: context engineering is mostly negative space — remove contradictions, name the right files, and make “run tests” unmissable. Sources: https://lnkd.in/eM-HnnGs https://lnkd.in/eN7pUsfY https://lnkd.in/eHAarmSC https://lnkd.in/e9Fx6UC7 https://lnkd.in/eJM2EHkh https://lnkd.in/eTqgZZqK https://lnkd.in/egk_dX8U #ContextEngineering #AICoding #CodingAgents #SoftwareEngineering #MCP #LLMs #DeveloperTools