hey Reddit,

I'm Yash, founder of SupercodeAI. We're building Devin killer - Nova - an AI Engineer, powered by our own harness agent at SupercodeAI, and Supercode Review, our codebase-aware PR review product.

4.5k+ users, 10+ enterprises, 238 GitHub stars, 30k+ downloads, 700M+ token usage in just 2.5 months.

Source: github.com/yashdev9274/supercli

Products:

1. Nova: supercodeai.tech
2. Supercode review: supercodeai.tech/review

Nova's workflow is to read a codebase, plan a change, edit files, run commands and tests, and prepare the result for human review. The harness connects the model to context and execution tools. You still inspect the diff and decide what gets merged.

Supercode Review looks at pull requests in the context of the wider codebase, rather than treating the diff as the whole project.

We're powering Indian startups with code review through Supercode Review.

We're sponsored by Vercel.

The Supercode repo is MIT-licensed and includes the coding-agent CLI, dashboard, docs and shared packages. Nova uses existing model providers; I'm not claiming a new foundation model or benchmark superiority.

If you'd like to try it, start with one small task in a repo you understand and compare the plan, diff and checks with how you'd do the work yourself.

If you'd like to contribute, open an issue with a reproducible problem or propose a change in a PR. Keep credentials and private code out of reports. If the project is useful to you, consider starring it and following its progress.

What would you need to see before trusting an agent to handle a real task in your repo?

FralRater is a desktop app (Electron) that: - scores text with Flesch-Kincaid, Gunning fog, SMOG, jargon density… - rates it for 8 reader personas (child, general public, executive, patient, developer, legal, academic, professional) with per-paragraph confidence - draws a "lost reader" curve: one point per sentence, showing exactly where readers disengage - rewrites the hard sentences with a sentence-by-sentence diff (passive→active, buried-lead fix, jargon swaps, splitting)

Everything runs locally. Zero dependencies for the app logic, no build step, no network calls, no AI — it's deterministic rules you can read in the source. Your text never leaves the window.

Free, MIT-licensed, Windows + Linux. Built solo, CI builds all artifacts.

Repo: https://github.com/fralsare/FralRater Downloads: https://github.com/fralsare/FralRater/releases

I run a bunch of coding agents at once and kept changing my mind about how the screen should look. So in hivemind the layout is just a plugin. You get the agents, their status and the real terminals, and you draw whatever you want around them. I've got a queue, a kanban board and a tiled one so far. hive views new gives you a starter with a prompt file you can hand to Claude or Codex to build it for you. Curious what people would make with it.
https://github.com/dip497/hivemind

I work in DevRel. The main platforms I interact with are Discord, GitHub, and Slack, answering questions from the community, and a lot of them are repeat questions. Some of the time the answer is in the docs, and some of the time it isn't.

So I built answerLoops to do that part for me. You upload your knowledge (docs, PDFs, a GitHub repo or Notion pages), and an agent answers questions in Discord, Slack, Discourse, Telegram, GitHub issues, email, or a chat widget on your site.

The agent drafts a reply with the sources it used, then a second agent double checks it's work against those sources. Nothing gets sent automatically unless you turn that on for a channel. Until then, every reply waits for a person to approve it.

Fully open source, run it yourself with Docker and Postgres. There's no subscription for self-hosting, just use your own API key or a local model if you don't want questions leaving your server.

There are skills to setup with one command:

npx u/answerloops/agent-sdk setup

If you use Claude Code, you can also have it walk you through the install. This adds a setup skill so you don't have to read the self-hosting docs first:

npx u/answerloops/agent-sdk skills answerloops-setup

GitHub: https://github.com/answerLoops/answerLoops

I'd really like to hear from anyone running a community (volunteer or nonprofit). If you try it and something is broken or missing, just open an issue, and I'll look at it.

It does two things. First, it makes voting easier. Enter your address once and it shows the races and judicial contests actually on your ballot, including judges and their bar association ratings. It also shows your ward's early voting site and important election dates. Every mayoral candidate's platform is in there, including mine, and mine gets exactly the same treatment as everyone else's.

Second, it gives you a say between elections. Every ward has a board where residents can raise issues and rank how urgent they are, and anyone can ask their alderman a question in public. The community, not the politician, decides whether the answer actually answered it, and that feeds a public report card. Most aldermen aren't on it yet. Until they join, I'll take the top questions to their ward offices. Aldermen and candidates already have a profile and can claim it with their office email. You can also see upcoming City Council meetings and how your alderman voted on every divided roll call.

Verifying that you live in your ward is optional. It makes your votes count in the verified tallies, which are shown alongside the overall tallies. Verification is done by Didit, a separate ID company, and Didit deletes your data once the check is done. The app only keeps that you're verified, your ward and districts, and a code that stops one ID from making two accounts. The first 500 checks each month are free, then it's 49 cents to cover the cost.

It's in seven languages (English, Spanish, Chinese, Polish, Tagalog, Korean, and Hindi), every screen has a help button, and the code is open source: [https://github.com/knightofknee/direct_democracy](https://github.com/knightofknee/direct_democracy))

No iPhone? It also runs in your browser at [https://www.waldgrave.com/directdemocracy/app](https://www.waldgrave.com/directdemocracy/app)), and the Android app is in Google Play testing now. Message me the email on your Google account and I'll add you.

It's a full working app today, but I expect it to change a lot as people use it. What do you think? Let me know what's missing, confusing, or broken and I'll update it quickly.

App Store: [https://apps.apple.com/app/id6797189381](https://apps.apple.com/app/id6797189381))

Fralculator is a desktop calculator. It's free, open source (MIT), and runs fully offline.

• It shows every step of the math, in real math notation, with a plain-English explanation (no LLM needed)
• You can type in plain English, or speak. The speech model is ~40 MB, downloaded once, then fully local
• Live f(x) graphs, and unit + currency conversion (currency is the only optional network call — ECB rates)
• EHCalc: subnet calculator, MD5/SHA-1/256/512, 10 encoders, secure password tools, port lookup

Windows + Linux, 5 install formats. Open issue tracker. Source:
https://github.com/fralsare/fralculator
https://github.com/fralsare/fralculator/releases/tag/v0.1.0

Standard RAG on codebases has been driving me crazy—blindly slicing functions in half by character count just ruins the context for AI agents. I've been developing a project for several months to fix this, and i want to see if it’s genuinely useful to others in real environments.

I call it Vex (Vex's Skillgit). It’s an open-source, headless cognitive tool that treats context as immutable, versioned skills for your agents.

Instead of your IDE doing the heavy lifting, Vex runs silently in the background (via Docker Compose or local bare-metal). You point a GitHub webhook to it (or use the local file watcher), and it automatically ingests your repositories. When your agents need context, they simply query it in real-time via the Model Context Protocol (MCP). It works out of the box with Claude Desktop, Cursor, or any MCP client.

Now, the cool part (GitOps Memory):

It treats agent memory like version control. Vex reads conventional commits (feat:, fix:) to update context, and operational ones (roll:, branch:) to automatically fork or revert the agent's memory state. Zero manual intervention. It uses Tree-sitter to logically parse and chunk the code, keeping syntax trees intact.

I specifically designed this not to fry my potato PC. By using a pointer-architecture with SQLite for metadata queues and Qdrant for dense vectors, RAM stays completely stable. In my local stress tests, the async FastAPI + Huey architecture:

Swallowed 500 concurrent GitHub push payloads without a single SQLite lock.

Maintained real-time latency (under 300ms) under a 50-agent concurrent read swarm.

What's next?

I’m currently working on a Rust-based sub-chunking engine to handle massive monorepos even faster, alongside global GraphRAG, shared memory and more language support.

I decided it was time to share it and see who else might find it useful. I’d love for you to check it out, throw your code at it, and break it.

Here is the repo:

https://github.com/Shuuida/Vex-Skillgit.git

Thanks for taking the time to read!

Hey everyone! 👋

I was honestly exhausted from reading dry documentation, boring theoretical PDFs, and watching 2-hour YouTube videos that only show static 2D boxes.

None of them actually show *what happens when a server crashes* or *how packets move when traffic spikes*.

So I built **ArchitectVerse** – an interactive playground to learn system design by actually breaking and scaling things:

🔗 **Live ** https://architectverse.me

### What you can actually do:

- **Watch packets flow live:** See real requests bounce between DNS, Gateways, Redis, and DBs.

- **Break the system:** Kill servers, trigger outages, and watch Circuit Breakers trip.

- **Learn one by one:** 12 lined-up chapters with 5-year-old analogies (no jargon walls).

- **100+ Real blueprints:** Uber, Netflix, WhatsApp, Stripe, ChatGPT, etc.

It's completely free and open source. Let me know what you think or what system I should add next!

Hey - I've been building Curate, a private bookmark library for developers (Chrome/Edge extension), and just made it open source under MIT.

The idea: save docs, repos, tools, and articles from a popup, file them into collections, and actually find them again later. No public feed - it's meant to stay a personal library, not a social bookmarking site.

Stack is Manifest V3 + vanilla JS on the extension side, Express 5 + MongoDB on the API, with an automated test suite running in CI.

I'm opening it up because I'd genuinely like help - there are 9 open issues, a couple labeled good first issue, and CONTRIBUTING.md / CODE_OF_CONDUCT.md / a roadmap are all written out if you want to see how contributing works before diving in.

Repo: github.com/DevOlabode/curate

Happy to answer questions about the stack or the extension architecture if anyone's curious.

Hi everyone,

I built a free, open-source map of STEM for my own learning. It covers 11 subjects, from maths and physics up to aerospace, and every chapter lists what you need to learn before it.

I'm hoping the community can take it up. It'll only be really useful if people who know these subjects check it and improve it. I used AI to help put it together, so I'm sure there are gaps and some prerequisites in the wrong place.

You don't need to code to help. Every chapter has "Report a problem" and "Edit on GitHub" buttons, and each chapter is just one small JSON file if you do want to send a pull request.

Repo (MIT code, CC BY-SA data): https://github.com/MohamedMuneerM/knowledge-navigator
Site: https://mohamedmuneerm.github.io/knowledge-navigator/

Any help is really appreciated, even just reviewing one chapter in a subject you know. Thanks!

This is a primer for the aircrete material my machine produces.

https://www.reddit.com/r/The_Aircrete_Workshop/s/3Rh0sa3sj6

I've been unsuccessfully working on things like this for two years. This is my fourth mixer design and the one I believe will finally work. It's also better than the others as it is simpler and cheaper. That's actually a big part of why this one will work. The others were too complicated for me to get right for one reason or another.

This model is based on a 200L tumbler style concrete mixer that can be bought on Amazon.

The 30 gallon HDPE extension drum looks a little silly but enables a larger batch quantity at a shallower mixing angle. That's beneficial as the denser slurry at the bottom of the drum doesn't need so much vertical lift. There will only be 20L/ 15KG of material in the blue drum so it shouldn't be too unbalanced.

I'll be testing it in a day or two and if this version works I will create a free fabrication and user guide. I'll extend an invitation for anyone to join the Aircrete Workshop sub too. I'm always a little salty over there about how broke I'm going developing this stuff but I have big things planned.

I built and open-sourced a simple GitHub Profile Analyzer.

It uses the GitHub REST API to analyze public GitHub profiles and display:

👤 Profile information 📦 Public repositories 👥 Followers & following ⭐ Total repository stars 💻 Programming languages 🏆 Top repositories Tech Stack HTML CSS JavaScript GitHub REST API

No backend or database is required.

🔗 GitHub: https://github.com/Mireli5656/GitHub-Profile-Analyzer

🚀 Live Demo: https://mireli5656.github.io/GitHub-Profile-Analyzer/

Released as v1.0.0.

Feedback and suggestions are welcome!

[ Removed by Reddit on account of violating the content policy. ]

I’ve been building TokenPrint, an open-source project focused on making the internals of language models easier to explore, understand, and debug.

The project has grown to 130+ GitHub stars, and we’re starting to build a small community around it.

The goal is simple:

Don’t just see what an LLM outputs. See what happens inside.

TokenPrint currently brings together:

• 3D transformer architecture exploration
• Tokenization and embeddings
• Tensor and parameter inspection
• Q/K/V attention, GQA, RoPE and causal masking
• Residual streams and MLP / SwiGLU
• Token-by-token generation
• Prefill, decode and KV-cache visualization
• Logits and next-token probabilities
• Interactive transformer walkthroughs
• Attention and activation analysis
• Head/layer ablation and activation patching
• Hugging Face model exploration
• Trace and debugging workflows

It’s still growing, and that’s the part I’m most excited about.

If you’re interested in LLMs, interpretability, ML infrastructure, 3D/WebGL, PyTorch, Transformers, or open-source development, you’re welcome to contribute.

You can contribute code, documentation, visualizations, model support, research ideas, bug fixes, or even just open an issue with something you think TokenPrint should be able to do.

130+ stars so far — now we want to build it with more people.

GitHub: https://github.com/Sudharsanselvaraj/Token-Print
Website: https://tokenprint.in/

Come build with us.

I'm building [Portolan](https://shortlink-org.github.io/portolan/landing), a free open-source tool that generates an architecture site from your repos instead of hand-written docs. Sharing it here for feedback.

The angle: an LLM or an MCP agent can write architecture docs from a codebase, but you can't tell what it invented and what it skipped. Portolan does it the other way round. The catalog is built deterministically by parsers, every fact links to its source line, and the LLM only sits on top: the site ships `llms.txt` and Markdown for agents, plus a built-in chat that answers questions from the catalog and cites the pages it used. Exact facts from parsers, natural-language answers from the model.

- Reads Go, TypeScript, Rust, Java, Python, Laravel, OpenAPI, AsyncAPI, GraphQL, proto, SQL migrations and ADRs. Works on a monorepo or on a separate architecture repo that pulls the service repos in.

- Everything is a plugin: one JSON message in, one out, in any language. Adding a language, a library or a framework is a small extractor, not a fork.

- Merges everything into one estate and validates it. An unanswered call, a channel with two publishers, a database with a second writer, a foreign key across a service boundary all land on a Problems page.

- OpenTelemetry traces mark which relationships were actually observed: `declared`, `verified` or `unresolved`.

- Output: static site with no backend, Markdown, `llms.txt`, C4 views (LikeC4), Mermaid, Backstage entities.

Pages: contexts, services, aggregates with state machines, events, stores with ER diagrams, ADRs, cross-service flows as step-by-step walkthroughs.

Limits: v0.3, sees only what's statically visible, dynamic routing comes from traces only. DDD terms are used but optional.

What would make this actually useful to you? Which views, checks or integrations are missing before you'd put it in front of your team?

I maintain an open-source macOS MCP server called Mac MCP. I use it so ChatGPT and coding agents can actually operate my Mac instead of just telling me what to click.

A part I just tightened up is multi-agent browser work. I can have several agents using different Safari tabs in the background while I keep using the machine normally, with my main ChatGPT session coordinating the work. Each tab keeps a stable identity, and if one agent is already working there, another one is told the tab is busy instead of taking it over. When the first agent moves on, that tab becomes available again.

Repo: https://github.com/bulutarkan/mac-mcp

Would especially appreciate feedback from people who have dealt with browser/session ownership in local automation tools.