r/AskVibecoders

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!

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

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)

been building solo for 2 years. shipped 11 things. zero of them made meaningful money. not "indie hacker lottery" zero, actual zero.

took a step back to figure out why and the pattern was the same on every one:

• built first, asked who'd pay after
• "validated" in twitter polls and reddit threads where free advice flows and money doesn't
• shipped MVP to 30 friends who said "nice"
• watched signups stall at 12 a week, called it a marketing problem

the marketing problem wasn't marketing. i was building things people would tolerate, not pay for. that's a different thing and free reddit feedback won't surface it.

what actually changed:

before writing a line of code on project 12, i posted a paid task asking 50 people in my niche to spend a week thinking about whether they'd pay for a tool that did X. the bounty was $5 per detailed response. spent like $250 total.

of 47 responses, 11 said they'd pay $20/mo for the v1 spec. 4 said they'd pay $50. the other 32 either said "i already use [tool]" (named existing solutions, useful) or "i don't have this problem". better data than 6 months of "this is cool" comments.

paid feedback beats free feedback because the person answering is committed. they read the brief, they write a real answer, they tell you which tools they already use. you can sort the data.

used Pond for it. people you've never heard of submit, you only pay the useful ones.

stopped building things nobody asked for. building things 11+ people have committed to via paid signal.

if you've been shipping into the void, the answer isn't more ads. it's better signal.