This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built I built the Closiq Discord Agent , a full-stack modular monolith engineered to transform a Discord channel into an automated, AI-driven customer support inbox and lead management system. When a customer messages your Discord support channel, the backend captures the conversation, handles data persistence, and fetches highly relevant context from a self-hosted Qdrant vector database (which indexes knowledge base documents stored in MinIO). It then leverages OpenRouter or OpenAI-compatible models to dynamically draft and deliver accurate, context-aware responses right back to the customer via a Discord bot. Demo GitHub Repository: ErOr-0/closiq-discord-bot Local Web Dashboard: http://localhost:5173 (Tip: Insert a GIF or a couple of screenshots here showing off your React dashboard interface, your MongoDB message log view, or the Discord bot replying live in a channel!) Tech Stack At A Glance Frontend: React + Vite Backend: Node.js + Express + TypeScript Databases & Storage: MongoDB (Metadata), Qdrant (Vector Embeddings), and MinIO (Object Storage) Integrations: discord.js & OpenRouter / OpenAI SDK The Comeback Story This project started as an ambitious idea but quickly stalled out. Before dusting it off for this challenge, it was just a loose collection of database models, basic tools, and a primitive, unoptimized LangChain loop sitting in a graveyard of unfinished local folders. It completely lacked a front-end management layer, and the architecture was fragile. To bring this project to life and cross the finish line, I focused heavily on stability, user experience, and structural boundaries: Modular Monolith Refactoring: Reorganized the entire Express backend into strict, clean module boundaries ( messages , knowledgebase , agent , infrastructure ) to make the codebase highly maintainable. Built the Web Dashboard: Created a comprehensive React interface from scratch so users can visually mon

Why Does Using an ORM Decrease Database Performance? While trying to optimize the shipping module in a production ERP, I noticed that database queries were incredibly slow. At first, I examined the SQL queries and checked the indexes. However, I couldn't get the performance boost I expected. The problem lay in the Object-Relational Mapper (ORM) library, which was the cornerstone of our application. ORMs make things easier for software developers by providing an abstract layer for database operations, but this convenience often comes at a performance cost. In this post, I will explain why using an ORM decreases database performance, using concrete examples from my own field experience. The core promise of ORMs is to keep developers away from SQL and allow them to interact with databases in a way that is more aligned with the object-oriented paradigm. This is a huge advantage, especially in small and medium-sized projects or rapid prototyping processes. However, when things get complex and performance becomes critical, the efficiency of the queries generated by ORMs starts to be questioned. In many cases I have encountered, especially in enterprise software development processes, the default behaviors of ORMs created an unexpected load on database servers. Query Inefficiencies Generated by ORMs ORMs usually manage database relationships using mechanisms like "eager loading" or "lazy loading". Depending on the developer's preference, these mechanisms either fetch all related data at once (eager loading) or fetch it in pieces as needed (lazy loading). However, ORMs may not always perform these loads in the most optimized way. For example, while only a few fields like ID and name are sufficient in a list view, the ORM might query the entire table or all related tables. This situation causes unnecessary data transfer and unnecessarily overloads the database server. To give an example, on the order list screen of an e-commerce site, we needed to display the customer inform

Disclosure: I work on Passlens, a browser-first passport and ID photo maker. This post is about the product decisions behind that workflow, not a neutral review of every tool in the space. A passport photo looks simple until you try to make one that an upload form will actually accept. It is a headshot, yes, but it is also a small chain of constraints: physical size, pixel size, background, head position, print scale, and whatever the destination country's portal decides to reject that week. That is why generic photo editors feel slightly wrong for this job. They can crop. They can resize. They can export. The hard part is not any one of those actions. The hard part is keeping all of them tied to the document rule the user picked. The unit problem For developers, document photos are awkward because two units matter at the same time. A user may need a 2x2 inch passport photo. A visa portal may ask for 600x600 pixels. A print sheet may need 35x45 mm photos at 300 DPI. These are not the same request, but people often treat them as if they are. If the app only thinks in pixels, the print can come out the wrong physical size. If it only thinks in millimetres or inches, the digital upload can be rejected for the wrong pixel dimensions. A good workflow has to keep both ideas alive: the document size and the export target. That is the main reason Passlens keeps presets and print layouts as first-class pieces of the workflow instead of treating them as labels on a crop box. The crop is not the output Another small trap: the crop the user sees is not always the final output. For a digital upload, the crop usually becomes one image file. For printing, the same crop may become several photos arranged on 4x6, A4, or Letter paper with spacing, margins, and optional cut marks. If that print sheet is scaled by the browser or printer dialog, the whole thing is wrong. So the editor needs to separate three things: the face and shoulder crop the finished document-photo size the print s

What if a development board could be as friendly as an Arduino, yet powerful enough to drive industrial-grade robots? That is exactly the gap the new G2 Nano sets out to close. Most hobby boards handle simple robot builds with ease, but they hit a wall once a project demands tight, simultaneous control of several motors. Embedded systems engineer Ryan Strace noticed that the custom controllers built for these complex machines tend to look remarkably alike, with motor coordination as the recurring headache. Rather than reinventing that hardware on every project, he designed a single accessible platform to handle it, and the G2 Nano is the result. Precise motor control usually leans on closed-loop techniques like PID, but real-world gremlins such as integrator windup, sensor noise, mechanical saturation, and phase delay can all degrade performance. Robots also need smooth multi-axis motion with managed acceleration to avoid jerky, stressful movement, plus solid fault handling so an unexpected state does not wreck expensive parts. Strace is tackling all of this with a low-cost motion-control IC he is developing, and the G2 Nano is the high-performance platform built to prove out that future chip. What's under the hood Processor: NXP Arm Cortex-M7 clocked at a brisk 1 GHz Wireless: u-blox MAYA-W1 module with dual-band Wi-Fi and Bluetooth Motion sensing: six-axis IMU (3-axis accelerometer plus 3-axis gyroscope) and a dedicated magnetometer for compass heading Form factor: just 0.8 by 3 inches, breadboard-friendly, on a six-layer PCB stackup for clean high-speed signals On the software side, the board targets native micro-ROS and the Zephyr real-time operating system, with planned MicroPython support so you can prototype in Python without paying the usual speed penalty, thanks to that unusually high clock. Every design file and document is open-source and published on GitHub. Build it yourself If you want to follow along, the core ingredients are clear: an NXP Cortex-M7 a

A lot of AI apps die in the same place. Not during the prototype phase. Not while testing...

Something broke in the AI pricing market between January and May 2026. A year ago, "frontier model" meant "expensive model." Claude Opus was $15/$75 per million tokens. GPT-4 was $5/$15. If you wanted the best coding performance, you paid the best price. The correlation between quality and cost was loose, but it existed. That correlation is gone. The Numbers That Changed Everything Here's SWE-bench Verified — the benchmark that tests AI models against real GitHub issues from projects like Django, Flask, and scikit-learn — plotted against output price per million tokens: Model SWE-bench Output $/1M Score/Dollar ───────────────────────────────────────────────────────────────── Claude Opus 4.7 87.6% $25.00 3.5 Claude Opus 4.6 80.8% $25.00 3.2 Gemini 3.1 Pro 80.6% $15.00 5.4 GPT-5.2 80.0% $10.00 8.0 DeepSeek V4 Pro (Max) 80.6% $3.48 23.2 Kimi K2.6 80.2% $4.00 20.1 Qwen3.6 Plus 78.8% $3.00 26.3 MiniMax M2.5 80.2% $1.20 66.8 DeepSeek V4 Flash (Max) 79.0% $0.28 282.1 Read that last line again. DeepSeek V4 Flash scores 79% on SWE-bench at $0.28 per million output tokens. Claude Opus 4.7 scores 87.6% at $25.00. The performance gap is 8.6 percentage points. The price gap is 89x . For a team running 100 million tokens per month, that's the difference between $28/month and $2,500/month. For a 9-point improvement in code completion accuracy. It's Not Just One Outlier This isn't a DeepSeek anomaly. Look at the cluster of models scoring 78-80% on SWE-bench: DeepSeek V4 Pro : $3.48/1M output — open source, 1M context Kimi K2.6 : $4.00/1M output — open source, 256K context MiniMax M2.5 : $1.20/1M output — open source, 200K context Qwen3.6 Plus : $3.00/1M output — open source, 1M context MiMo-V2-Pro : $3.00/1M output — open source, 1M context Five models from five different Chinese labs, all scoring within 2 points of GPT-5.2 ($10.00/1M) and Gemini 3.1 Pro ($15.00/1M), all at 1/3 to 1/10 the price. And they're all open source. What Happened Three things converged: 1. Mixture-of-Exper

According to the complaint, a Google engineer risked over $2.7 million on wagers related to Google's 2025 Year in Search campaign.

Author: Tobie Morgan Hitchcock Three months after 3.0 went GA, we're excited to announce that...

Lately I’ve noticed that a lot of people seem emotionally drained from constant social media interaction, notifications, and online pressure. But interestingly, many people seem completely comfortable talking to AI for hours especially when the interaction feels calm and non-judgmental. It’s interesting how many users say they don’t even want “romantic AI.” Do you think AI companionship could eventually become part of digital wellness rather than just entertainment? submitted by /u/Nearby-Ad-8924 [link] [留言]

submitted by /u/chicametipo [link] [留言]

Most multi-agent setups I've seen treat agents like isolated workers. Each one gets a task, runs it, returns a result. No awareness of each other. No way to coordinate. Just parallel execution with a shared clipboard. I've been building a multi-agent framework in public for about 4 months. 13 agents, 8,400+ tests, 135 stars. Here's the thing I didn't expect to matter most - communication. Each agent in my system is a domain specialist. The mail system only thinks about mail. The routing system only thinks about routing. They live in their own directories with their own identity files, their own memory, their own tests. A hook fires every session to load identity before anything else runs. No agent boots cold. The problem was coordination. Agents can't write files outside their own directory - there's a hard block that rejects cross-branch writes. That's by design. But it means an agent that finds a bug in someone else's code can't just go fix it. So I gave them email. Here's what I expected: agents would share data. Pass results around. Maybe sync state. Here's what actually happened: the first thing they did was file bug reports against each other. One agent finds a test failure in another agent's domain. It sends an email: "Hey @routing, your path resolution fails when the branch name has a dot in it. Here's the traceback." The routing agent gets woken up, reads the mail, and fixes it. No human in the middle. There's a difference between "send" and "dispatch" - send drops a letter in the mailbox. Dispatch drops the letter AND rings the doorbell. It spawns the agent and points it at its inbox. drone @ai_mail send @routing "Bug report" "Path fails on dotted names..." drone @ai_mail dispatch @routing "Fix needed" "Traceback attached..." Send = mail. Dispatch = mail + wake. The mail agent has 696 tests. Not because someone sat down and wrote 696 test cases. Because it kept breaking in production and every fix got a test. The routing system has 80+ sessions of experien

I'm hoping for some advice from any former PhD's outside of machine learning. If you made it into machine learning engineering and/or data science, what was the key for you? Any tips for this job market? It seems like non computer science PhD's are especially in trouble at the moment. submitted by /u/Electrical_Fan_9587 [link] [留言]

Let your agent trade Discussion | Link

This isn't a doomer post. It's a pattern I've been watching closely and people does as well and I think it's worth an honest discussion. The old model of secret leakage was human error. Developer moves fast, forgets to add .gitignore, commits a .env file, moves on. Happens, but it's recoverable, it's traceable, and most teams with basic hygiene catch it. The new model is different. AI coding agents Cursor, Copilot, Devin, Claude in agentic mode, pick your flavor write, commit, and push code at a speed no human review process was designed to handle. They don't have security intuition. They have pattern completion. And the patterns they've learned from are full of examples where credentials live in config files, environment strings get hardcoded "temporarily," and API keys appear inline because that's what the training data showed works. Here's what's actually changing: Volume. A developer using an agent ships 3 to 5x more code per day than without one. That's 3 to 5x more surface area for mistakes per developer per day. Review gaps. Nobody carefully reviews AI generated code the way they review handwritten code. The psychological contract is different "the AI wrote it" creates a diffusion of responsibility that security doesn't survive. Commit frequency. Agents that push directly (and more teams are allowing this) bypass the natural pause where a human might notice something before it hits the remote. Context blindness. An agent given a task like "integrate Stripe payments" will do exactly that including pulling in the live key from wherever it can find it, because that's what completes the task. I've been building a tool that scans for exactly this class of problem and the number of exposed credentials I'm seeing in repos created in the last 6 - 12 months versus repos from 3+ years ago is not subtle. The slope is steep. The solutions people reach for pre commit hooks, secret scanning in CI were designed for human paced development. They're not keeping up. Curious if

Plan and track your trips privately Discussion | Link

Problem Statement We have a misinformation problem. But more specifically, we have a speed problem. A journalist spots a suspicious claim. They search for sources. Cross-reference databases. Call experts. Write a verdict. Get it edited. Publish, maybe 6 hours later. Maybe 3 days later. Meanwhile, the original claim has been screenshot, reposted, quoted in newsletters, and cited in arguments across five platforms. I wanted to build something that closed that gap. Not a chatbot that guesses. A proper pipeline, one that retrieves real evidence, reasons from it, and tells you why it reached a verdict. That's what Sift is. What is Sift? Sift (Source Inspection & Fact-checking Tool) is an open-source multi-agent AI pipeline that takes any text, extracts every factual claim, retrieves grounded evidence, and returns auditable verdicts — TRUE, FALSE, or UNCERTAIN, with cited sources and full reasoning chains. Paste a news article. A politician's speech. A viral statistic. A WhatsApp forward. Sift breaks it into individual claims and fact-checks each one independently. Why Multi-Agent? The naive approach is to ask an LLM: "Is this claim true?" The problem: LLMs hallucinate. They have knowledge cutoffs. They're confidently wrong in ways that are hard to detect. And critically, they don't show their work. A single LLM call can't reliably handle the full pipeline of: Extracting structured claims from noisy text Retrieving dated, traceable evidence from live sources Reasoning across conflicting evidence without confabulating Adversarially reviewing its own conclusions for overconfidence Finding corrections when something is wrong Each of these is a distinct task that benefits from its own prompt, its own tools, and its own failure modes. That's why I built five separate agents, orchestrated with LangGraph. The 5-Agent Pipeline Agent 1 — Claim Extractor A single paragraph can contain 4-5 distinct factual claims. Generic LLMs miss them or conflate them. This agent uses LLaMA 3.3 70