r/AskVibecoders

Figured I’d post mine as well since Cursor limits how many referral signups work each month

Referral gives 50% off the first month on Cursor Pro,Pro+,and Ultra plans:
https://cursor.com/referral?code=V6CY3ZZOOPEX

Looks like it’s for new accounts / first paid signup only. I also get usage credits if someone signs up through it (ill give you a smooch)

Been using Cursor a lot lately for React,Swift,and general AI workflow stuff so figured someone here might get use out of it.

Been lurking here for a while and finally shipped something worth sharing.

A few months ago I got obsessed with a simple question: how accurately can

AI determine the location of a random photo? Not just "probably Europe" —

actual coordinates.

Turns out it's a genuinely hard problem. The naive approach (just ask

Claude/GPT to look at the image) gets you maybe 40-50% accuracy on

urban photos and falls apart completely on rural ones.

So i went deeper. The pipeline I ended up with:

1. EXIF extraction first — if GPS metadata exists, done instantly, zero AI needed. Covers ~20% of mobile photos.
2. Visual feature extraction via a fast/cheap model — pulls out specific searchable elements (architecture style, visible text, infrastructure details) with a specificity score. Low-score generic queries get dropped before they waste API calls.
3. Google Vision Web Detection + Landmark Detection in parallel — if the image exists somewhere on the web or contains a known landmark, this catches it.
4. Web search on the high-specificity queries — feeds real-world results back into the final reasoning step.
5. Final reasoning with a stronger model that gets the image + all aggregated context. Contradiction detection built in — if web results point to 3+ different locations it flags it and tells the model to weight visual analysis higher.

Total cost per analysis: under €0.02. Most of the accuracy gains came from steps 2-4, not from using a more expensive model.

The interesting failure cases:

- Photos with visible text are almost always nailed correctly

- Rural/forest photos are still genuinely hard regardless of pipeline

- The AI confidently wrong cases dropped significantly once I added

the web search layer

Built it as a SaaS with multi-prediction output (up to 4 ranked

hypotheses with confidence %), radius estimate, and a 3D map view.

Still early but the technical side was interesting enough to share.

Happy to go deep on any part of the pipeline if useful.

So basically, I did deep technical research into the tools and methods people use for this (basically anyone can replicate it), how the process works, and how it’s also being used for training smaller models and in the process they make million dollars.

here is the deep research over it if anyone is interested

https://x.com/HarshalsinghCN/status/2056626175959826692?s=20

let me know your views about this, also this is long article not for doomscrollers

Been working on Repowise for a few months now. The core idea: AI coding agents are only as good as the context they get. Most of the time, that context is terrible.

Cursor reads your files. It doesn't know your architecture. It doesn't know which files break the most. It doesn't know why you made that weird design decision in auth six months ago.

So I built a layer that sits between the codebase and the agent.

Four things it does:

1. Parses your AST into a dependency graph (NetworkX). Agents can reason about structure.

2. Mines git history into hotspot and ownership maps. Who wrote what, what breaks most.

3. Generates an LLM wiki of your codebase and stores it in a vector DB. Always in sync.

4. Captures architectural decisions as ADRs so agents have intent context, not just code.

Exposes 8 MCP tools. Works with any MCP-compatible agent. Also has a local web UI to explore the graph and docs yourself.

AGPL + commercial dual license. Self-hostable.

Got a few hundred GitHub stars pretty fast. Then someone cloned it on PyPI three times in a week violating the license, had to file a DMCA. Wild week.

Happy to answer questions on the technical side or the distribution side. Both have been interesting.

Repo: https://github.com/repowise-dev/repowise

Dogfooding on website: https://repowise.dev

A star would really help with visibility!

Hi everyone,

Working with LLMs on modern C++ codebases usually hits a wall very quickly: context windows get flooded with massive files, and most standard indexers still struggle with C++20 Module partitions and imports.

We are currently running a live development workflow on a large-scale commercial project consisting of over 7,000 source files, mostly utilizing C++20 modules.

We managed to establish a highly performant workflow using the Codex App on the desktop, combined with VS MCP, IDAP MCP, and a dedicated lightweight tool we created to bridge the C++ gap: mcp-cpp-project-indexer.

The Problem We Solved

Standard file-dumping or naive regex indexing either sends thousands of lines of irrelevant code to the LLM (costly and slow) or completely loses track of C++20 module dependencies.

Instead of trying to replace a full compiler/LSP (like clangd) or performing heavy semantic analysis, our indexer acts purely as a stream- and token-based locator. It maps out files, symbols, and module structures, providing the LLM with exact line references (startLine/endLine).

The Setup & Results

• The Stack: Codex App + VS MCP + IDAP MCP + mcp-cpp-project-indexer.
• Token Reduction: The LLM only requests and reads the exact code fragments it actually needs. This reduces the text sent to the LLM by up to 86%.
• Performance: Written in Python, it includes a file watcher mode that calculates hashes incrementally. It stays up-to-date in real-time during active development without hammering the CPU.
• Intelligence: Code/ChatGPT confirmed that the context routing works flawlessly even at this 7,000-file scale.

Why share this?

When we started, we couldn't find a lightweight, production-ready way to make Claude/GPT understand a massive C++20 module graph without spending a fortune on API tokens or waiting ages for context processing. This setup proved that the Model Context Protocol (MCP) is absolutely ready for large enterprise codebases if decoupled correctly.

The project is fully open-source. If you are struggling with C++ context limits or modules in your AI workflow, feel free to check it out, spin it up, or contribute:

👉 GitHub: github.com

I’m happy to answer any questions about how we configured the MCP synergy or how the incremental indexing handles the C++20 module tree!

Anthropic recently published their harness design for long-running apps - a multi-agent architecture inspired by GANs where a Generator builds code and an Evaluator critiques it in a loop.

I built my own version using Kiro CLI and used it to generate a marketing website for my project Mnemo (persistent memory for AI coding agents).

The architecture:
Planner (runs once) → Generator ↔ Evaluator (12 iterations)
Each agent is a separate CLI process with zero shared context. They communicate only through files (spec.md, eval-report.md). The Evaluator uses Playwright to actually browse the live site - not just read code.

What made it work:

Clean slate per invocation — each agent starts fresh, reads only its input files. Prevents context anxiety.

Playwright MCP for testing — the evaluator navigates, clicks, resizes viewports. Catches visual bugs code review never would.

Anthropic's frontend design skill — explicitly penalizes generic AI patterns (Inter font, purple gradients, card layouts). Forces creative risk-taking.

Continuous iteration, not retry-on-failure— all 12 rounds run regardless. Each one improves.

The progression was wild:
Iteration 1: Exactly what you'd expect from AI - functional but forgettable

Iteration 4: Generator pivoted to "Terminal Noir"
IBM Plex Mono, amber on black, grain textures, scanlines. This is the kind of creative leap that doesn't happen in single-shot generation.

Iterations 5-12: Polish, accessibility, responsive fixes, reduced-motion support

Stats:
Total time: 3h 20min
Iterations: 12 (generator + evaluator each)
Manual code written: 0 lines
Tech: Next.js, Tailwind, Framer Motion, TypeScript

Live result: https://mnemo-mcp.github.io/Mnemo/

Key takeaway: The model is the engine. The harness, the constraints, feedback loops, and adversarial structure around it, what determines whether you get AI slop or something genuinely distinctive.

Happy to answer questions about the architecture or share the prompt files.

Built a small Chrome extension called VibeApp Exporter because I got tired of manually rebuilding projects from AI app builders 😅

I was using tools like Lovable, Bolt, Base44 and Rork on their free plans. The annoying part was that exporting projects properly usually wasn’t available for free users.

So every time I wanted to continue the project locally in VS Code, I had to:

• manually create folders
• create nested subfolders
• copy each file one by one
• paste code manually
• rebuild the whole structure myself

It became super time consuming once projects started getting bigger.

So I built an extension that:

• detects the project tree
• opens nested folders automatically
• extracts files + code
• preserves exact folder structure
• exports everything into a ZIP

It currently supports:

• Lovable
• Bolt
• Base44
• Rork

Everything runs browser-side and the code isn’t uploaded anywhere.

Honestly started as a personal pain-point project but figured other vibe coders probably deal with the same thing.

Still improving extraction reliability for different builders and edge cases, but it’s already saving me a lot of time.

Install for Free: VibeApp Exporter

Disclaimer: I'm the developer of this tool.

Been working in network engineering for years. The constant context-switching between SSH sessions and AI tools was killing my workflow — copy output, paste to ChatGPT, get a suggestion, go back to terminal, repeat.

So I built something that keeps the AI inside the terminal itself. Three modes: Read Only (safe inspection), Fix Mode (approve each command), Auto Pilot (autonomous). Works through jump hosts, auto-detects vendor syntax, never sends your configs to our servers.

Still early — would love feedback from people who actually live in terminals. What's missing? What would make you switch from your current client?

→ netcopilot.app (free download, open source)