Maximizing Distance Between Points on a Square with Binary Search

Vibe coding is a trap that will eventually break your production environment. Speed is an illusion when you do not understand the underlying logic. You prompt an AI, copy the TypeScript component into your Next.js project, and the tests pass. It feels like peak productivity until a major traffic spike hits. Suddenly, your Spring Boot backend crashes because that AI-generated search component lacked a simple debounce function. It fired a new SQL database query on every single keystroke. At 3:00 AM, the system is down and AI cannot read your specific server logs to save you. This is exactly when the senior engineer logs in, reads the stack trace, and spots the missing logic. They deploy a two-line fix and restore the application in exactly eight minutes. The difference is not typing speed, but the possession of a complete mental model of the architecture. If AI writes code beyond your limits of comprehension, you cannot debug it when it fails. I build my frontend and backend systems by understanding the core logic first, rather than relying on generated output. You must choose to get slower now to become exponentially faster later. Here are three architectural rules to survive the AI era: -Build mental models before writing logic. Do not delegate core architectural decisions to an LLM. -Isolate AI to boilerplate. Use it to scaffold basic Spring Boot configurations or Tailwind layouts, never for critical execution paths. Master system debugging. -Reading raw server logs and understanding database execution plans will outlast any prompt engineering trend. #SoftwareEngineering #WebDevelopment #Nextjs #SpringBoot #TypeScript #Java #SystemArchitecture #DeveloperProductivity #CleanCode

I didn’t break my code. I broke my environment. And that lesson changed how I build software forever. For the past few days, I was working on an OCR-based backend system. Everything looked correct - the logic, the APIs, the flow. But nothing worked. Errors kept changing: • “No module named paddle” • “set_optimization_level not found” • “NumPy ABI mismatch” • “PyMuPDF build failed” At first, I thought: my code is wrong. But the truth was harsher - and more important: 👉 In real-world systems, code is only 50% of the problem. The other 50% is environment, dependencies, and compatibility. Here’s what I learned (the hard way): 🔹 Version mismatch can break everything Even if your code is perfect, incompatible library versions will crash your system. 🔹 Python version matters more than you think Some ML libraries still don’t support newer versions (like 3.12). 🔹 Virtual environments are not optional If you don’t isolate dependencies, you’ll chase ghosts for hours. 🔹 NumPy 2.0 broke half the ML ecosystem Real-world lesson: “latest” is not always “stable”. After fixing everything, the system finally worked. Not because I wrote better code - but because I understood the system behind the code. 💡 Biggest takeaway: A good developer writes code. A great developer understands the environment it runs in. If you’re building in AI/ML or backend systems, remember this: 👉 Your real skill is not just solving problems - 👉 It’s debugging chaos. #SoftwareEngineering #BackendDevelopment #AI #MachineLearning #Debugging #Python #DeveloperJourney #BuildInPublic

I've just open-sourced ast-outline 🦀 If you're using LLM coding agents like Claude Code, Cursor, or Copilot Workspace, you've likely noticed they spend an enormous amount of context window (and money!) reading entire source files just to understand what methods exist or where a class is defined. ast-outline acts as a pre-reading layer for AI. Instead of feeding agents the full 1,000 lines of an unfamiliar file, ast-outline extracts the structural shape (classes, signatures, fields, and doc comments with precise line numbers) and drops all method bodies. This leads to 5–10x token savings and lightning-fast codebase exploration. Once the agent spots the method it needs, it can read exactly L42-L58. 🚀 Key Features - Speed: Directory scanning is parallelized with rayon. ast-outline digest src/ completes in milliseconds. - Zero Dependencies: A standalone binary leveraging the incredibly fast ast-grep (tree-sitter bindings) ecosystem. - Beautiful Output: It colors syntax for humans in the terminal, but automatically falls back to raw text when piped to an agent. - Languages: Out-of-the-box structural mapping for Rust, Python, TS/JS, C#, Go, Java, Kotlin, Scala, and Markdown. Take a look on GitHub, and if it speeds up your agent workflows, drop us a star! 🌟 https://lnkd.in/g6k5c64f 📦 Install: - Homebrew: brew install aeroxy/ast-outline/ast-outline - Cargo: cargo install ast-outline

Every time I opened a pull request, I felt it. That awkward wait for feedback. What if the first round of review didn't have to wait at all? That question became my MEng Capstone at the University of Cincinnati. My inspiration was simple: combine the AI with traditional web development to solve a real developer pain point. So I built an AI-Powered Pull Request Reviewer, a GitHub App that automatically analyzes code the moment a PR is opened and posts intelligent feedback directly in the thread. And I did it entirely with free resources, even for deployment: React frontend on GitHub Pages FastAPI backend on Render MongoDB free tier for storage 4 AI providers (Hugging Face, Groq, OpenRouter, SambaNova) via free inference APIs, and the architecture is flexible enough to plug in many more! Biggest lesson? Real engineering happens when you work within real-world constraints and still ship something end-to-end. 🔗 Frontend (Live): https://lnkd.in/gkGF-PWE 🔗 Frontend Code: https://lnkd.in/ggJyY-Bc 🔗 Backend (Live): https://lnkd.in/gYHUkmwX 🔗 Backend Code: https://lnkd.in/guRag2ht 🔗 GitHub App: https://lnkd.in/gVZFYcWN #AI #SoftwareEngineering #GitHub #CodeReview #FastAPI #React #CapstoneProject #UniversityOfCincinnati #BuildingInPublic #Opensource #CICD

Bridging the Gap Between Web Development and AI Architecture Most tutorials show you how to call an LLM API. But in production, "just calling an API" is a recipe for a crashed server and a frustrated user. To wrap up our recent Python & Django bootcamp with Django Rwanda, I delivered a final session on building Production-Ready RAG (Retrieval-Augmented Generation) Systems. I’m sharing the full presentation today to help both beginners and experienced engineers understand that RAG isn't just about AI, it’s about a reliable data pipeline. Key takeaways included in the guide: - The Worker Pattern: Why you should never run AI logic inside a standard Django view (and how Celery saves your UX). - Observability as a Priority: Using the Django Admin as a "Command Center" to make invisible ingestion errors visible. - Beyond Simple Search: Why Hybrid Search (Vector + Keyword) is the standard for accuracy. - The Re-ranking Layer: How to move from simple "mathematical similarity" to true contextual relevance. - Whether you are just starting with Python or you are a Senior Architect looking to integrate LLMs into your stack, I hope this provides a clear mental model for your next project. #DjangoRwanda #PythonRwanda #AI #SoftwareArchitecture #RAG #DjangoRwanda #SoftwareEngineering

Here’s the truth no one tells you 👇 I just completed 30 Days of JavaScript on LeetCode. I didn’t magically become a “pro”. I struggled. I used GPT. I got stuck… a LOT. But something changed. I stopped seeing problems… and started seeing patterns 🧠 Here’s what I learned: Most problems repeat the same ideas Arrays, HashMaps, Two Pointers You don’t need to solve everything. You need to understand patterns Looking at solutions is NOT cheating. Blind copying is. Consistency beats motivation The real skill is thinking, not coding Code is just the output If you're starting LeetCode: Don’t aim to solve 1000 problems. Aim to understand 10 patterns deeply. That’s the real game. Next goal: Data Structures & Algorithms deeper 🚀 If you're on the same journey, let’s connect and grow together. - Ahmar Ali Khan

🚀 Car price prediction ML Project – Part 3: Bringing Model to Life (Flask API + Frontend) In my previous posts, I built and trained a Machine Learning model. Now in Part 3, I focused on turning it into a real-world application using Flask and a simple frontend. 🔹 What I built: • Developed a Flask API to serve the trained ML model • Created endpoints to take user input and return predictions • Designed a basic frontend (HTML/CSS/JS) for user interaction 🔹 How it works: User Input → Frontend → Flask API → ML Model → Prediction → Display Result 🔹 Tech Stack: Python | Flask | HTML | CSS | JavaScript 🔹 Key Learning: • How to deploy ML models using APIs • Connecting frontend with backend • Handling real-time user inputs 📌 This step helped me understand how ML projects work in real-world applications. Next Part: Deployment (making it live 🚀) #MachineLearning #Flask #WebDevelopment #Python #DataScience #Projects #LearningJourney

From intent to deep code: How using GitHub spec‑kit to live the doctrine. Don’t just talk about the four pillars; eat our own dog food. Building a zero‑dependency Haversine CLI calculator to demonstrate Deep Code (math from primitives, educational errors). But the real story is how we built it: using spec‑kit (https://lnkd.in/eR8A9sni.) Here’s what spec‑kit is offering: 🧠 Intent Code first Writing spec.md, plan.md, and tasks.md before a single math.sin(). That’s not paperwork; it’s a machine‑readable contract between product, engineering, and AI agents. 🧱 Foundational Code ready spec‑kit auto‑generated pyproject.toml, agent instructions, and even a constitution.md. The substrate outlives the app. ⚙️ Deep Code made visible With a clear task list (37 tasks, 15 parallelisable), focusing entirely on implementing the haversine formula with comments, tests, and zero hidden magic. 🕳️ Void Coding respected spec‑kit never forced us to over‑specify. We left gaps (altitude? batch mode? i18n?) as deliberate voids; invitations for future exploration. The result? A production‑ready CLI tool that teaches spherical geometry, runs in seconds, and has essential test coverage. All while following a doctrine. 👉 If you care about stable, observable, aligned systems; try spec‑kit. It turns "intent" into executable tasks, not wishful thinking. 🔗 Germaneering Blog: https://lnkd.in/eMT7Trna 🔗 Repository: https://lnkd.in/eP3H_qCn What’s your experience with spec‑driven development? Have you used spec‑kit or similar tools? Let’s discuss in the comments.

Most developers read code. Vloei lets you see it. I'm not a developer by trade. I work in infrastructure. But I wanted to understand how AI coding agents write code, so I built something to help me. Vloei is a free VS Code extension that turns your codebase into an interactive dependency graph. It runs entirely on your machine, no API keys, no data leaving your environment. It spots things that are easy to miss when you're reading file by file: Files that are too big or doing too much Circular dependencies Deep dependency chains Hotspots that will cause ripple effects when changed It's been especially useful when working with AI agents. They write fast, but they don't always write clean. Vloei gives you a visual way to catch that before it becomes a problem. Supports 15 languages including TypeScript, Python, Go, C#, Bicep, KQL and PowerShell. Would love feedback from anyone who tries it on their own project. 👉 https://lnkd.in/gt452nC4

🐍 ⮕ ⚡What I Learned From Porting 200,000 Lines of Code From Python to Typescript Over the span of just three days, we ported 184k lines of code and 147k lines of tests across 27 packages using Claude Code agent teams. The tests were green, the code looked complete. Did it actually work? Of course not! 🙃 The Master of Placeholder Stubs 🎭 It turns out Claude is a virtuoso at writing placeholder stubs. Our swarm of agents produced a mountain of fake implementations, and they didn’t feel the need to mention it. 🙊 Here are a few highlights from the "hall of shame": 📡 The Ghost Nodes: Our Discord and Telegram trigger nodes declared full event schemas. In reality, the implementation just called /users/me and never listened for a single message. 🎨 The Silent Failure: An SVG generator node that, if an LLM call failed, would silently return a gray rectangle with the prompt rendered as text. 🎧 The Audio "Mixer": An AudioMixer that declared five volume props but ignored all of them, mixing raw WAV bytes into unplayable noise. That’s three distinct bugs in a single 60-line function. 🤥 The "Cheeky" Tester: My personal favorite was a suite of unit tests designed to always pass, solely to inflate the test coverage metrics. Very clever! 🔍 The Pattern of "Surface-Level Correctness" The trend was clear: LLMs produce code that looks right. It has the correct field names, the right types, the appropriate props, and perfect imports. There’s just one caveat: it doesn’t actually do the work. Type-checkers and unit tests can't catch this. Only real execution with real inputs reveals the clown show. ✅ The Reality Check We spent the next four weeks doing the actual heavy lifting: running workflows, verifying outputs, and writing grueling end-to-end tests to replace the "smoke and mirrors" the agents left behind. Was it still worth it? Hell yes. Without AI, this would have been a 12-month slog. Instead, we're already live, and the performance gains from our new Node.js backend bring me joy every single day.