u/Strange_Owl_6291 1d ago

A harness and agentic IDE

A full coding environment for developers building software with AI agents. A harness, not a wrapper. Every agent in one view. Your machine, your keys or local models. Nothing routes through us.

https://voidleap.com/

---

Many agents
Voidleap Code is a full agentic IDE where you run as many threads and agents as the work needs, with every tool built in. If you need to edit something manually, the editor is right there.

One view
every provider tool has its own agent and skill setup, and when you switch, you start over. In Voidleap you set up once, and it works with every model. Swap models mid-conversation and keep the whole thread. Mixing models is not a feature we bolted on; it is the reason the harness exists.

Nothing hidden
you see the context every agent holds, and you can edit it. You see what each subagent did, which tools it ran, where the tokens went.

2

u/Historical_Date_8024 1d ago

⁠FreyaCad
Totally forever free and opensource 3D CAD in the browser. With no downloads. You don’t even ever have to provide your email.
Totally vibe coded with ChatGPT and Claude
Its for 3d printing designs like custom gridfinity but also for assemblies and i’m working on drawings
Please come try it and use the form on my home page at freya.co.nz to suggest any, improvements or report bugs.

2

u/daniel7_m 1d ago

For years, I kept searching for the productivity app that would finally organize everything.

I tried task managers, note-taking apps, habit trackers, calendars, and more complicated “second brain” systems than I’d like to admit. Notion came closest. I became a Notion creator and started building and selling templates, but I eventually ran into the same problem: I was still adapting my life to someone else’s platform.

What I really wanted was my own system.

So I started building it for myself, with AI doing a lot of the heavy lifting. It began as a personal side project—a place for my tasks, projects, notes, habits, calendar, goals, and life planning.

Then it grew into something I was using every day.

That project became Solum OS: an all-in-one personal productivity system that you can own and customize. Instead of another SaaS subscription, you get the actual application and its source code. The idea is to start with a complete system and use AI to reshape it around the way you work.

The video shows the current product, not a mockup. It has been a slightly surreal jump from making Notion templates to building full software, especially with how much AI has changed what one person can create.

I’m now turning Solum OS into a real product, and I’d genuinely love feedback from other builders:

Does the ownership/customization angle make sense?
What would you want to see in a personal operating system?
Is there anything in the demo that feels confusing or unnecessary?

Still early, still improving it, but it’s finally the productivity app I was looking for.

getsolumos.com

2

u/gandazgul 1d ago

I love the Build animation on the site, have it play dropping the letter on first load instead of jumping after I think the effect will land well.

In the live demo at least, the side back quick links has its own scroll bar, avoid this is annoying to scroll, I would also increase a font a bit, maybe I'm getting old :) but I found it a bit too small.

I would use something like this for sure. Can you add nagging reminders, as in some tasks keep reminding me until I mark them as done.

2

u/daniel7_m 1d ago

Great feedback, thanks a loot

2

u/Scholeristical 1d ago

What: Resume Rerun (https://resumererun.app/) - a resume tailoring tool that refuses to run on jobs you’re not a fit for.

Problem: most tailoring tools assume the answer is yes and rewrite until the resume matches the posting. That drifts toward inventing skills you don’t have. This one gives a fit verdict first - Strong, Moderate, Weak, Pass - and stops on Weak or Pass instead of generating anything. The cover letter and prep sheet are gated in code, not just discouraged in the prompt.
Who it’s for: people applying to a few roles they’re close to. Wrong tool for volume applications.

Feedback wanted: does a tool telling you no read as useful or broken? Also curious if anyone has run Tectonic on serverless and hit cold start issues.

Affiliation: I built it. Solo, free, no accounts, no payment. Invite-code gated because of a daily capacity ceiling - reply and I’ll send one.

2

u/fromkrish 1d ago

I built an open-source referee for AI coding agents.

I wanted to test whether an independent tool could verify an agent’s work, Pen testing it, and making changed only in serious vulnerable or buggy areas, so I gave an AI coding agent a broken MiniShop app and recorded the whole process. The agent writes the fixes. OpenPitStop checks whether they actually hold and work.

GitHub: https://github.com/Krish-1507/OpenPitStop

I’d especially like feedback from people using Claude Code, Codex CLI, Cursor CLI, Gemini CLI, OpenCode etc.

1

u/gandazgul 1d ago

This is super cool and similar to something I've been working on this whole year, I've turned it into an entire end to end harness and I would love if you gave it a try, I will try PitStop as well with Codex CLI although I rarely use those anymore for coding.

https://github.com/gandazgul/runwield

2

u/fromkrish 1d ago

Sure! I'll check it out!

1

u/Mueller96 1d ago

Lovable’s revert is all-or-nothing, I am building a tool that reverts single-prompt changes instead

Been building on Lovable and keep hitting the same wall: when a prompt broke something, the only way back is a full revert to the last good state. That jumps the whole project back to that point in time, there is no partial undo. Everything built after that point survives in the chat log, but getting back to where you were means manually reapplying it prompt by prompt.

The obvious pushback is “just use git“, commit at working points, revert per-file, read diffs. Fair for anyone comfortable in a git workflow, but a lot of people building on Lovable specifically aren’t. That’s part of the appeal of the tool in the first place. Asking them to read diffs and manage commits defeats the point of using it.
Another common approach is just trying to fix the issue by prompting your way out of it, but this is often times causing just even more issues.

So I’m building PromptTrail: it reads the plain-language change summary Lovable already writes for every prompt, as well as the commits in the connected repository. Providing users the possibility to easily revert individual prompts without the need to learn how to use git.

Still early in the project, only the landing page and waitlist are up (prompttrail.muellermoritz.dev), but I plan to release the first version in the next weeks.

Genuinely curious whether this is a real gap for people, or whether “just use git” really is the right answer for most vibecoders and I’m solving for an edge case. Would love to hear your opinions.

1

u/Friendly_Chip_6695 1d ago

Built a CLI tool that scans your codebase and generates a dependency map to find dead imports before they pile up, uses a local LLM to guess which ones are actually unused so it's not just regex matching. It's for solo devs or small teams tired of their linter missing things. Would love feedback on the false positive rate if anyone gives it a spin.

1

u/gandazgul 1d ago

Link

1

u/PomeloCommon4875 1d ago

Link please

1

u/mannyocean 1d ago

https://datatorag.com The MCP gateway for your Google workspace.

Claude’s google connector has gmail, drive and calendar. no sheets, no slides, and it can’t edit a doc you already have. Here’s one that does all three. Connect your account and ask it to update the spreadsheet.

1

u/donk8r 1d ago

Affiliation: I build this.

octocode, an MCP server that indexes a repo into a knowledge graph so an agent can find code by meaning and then walk the import and call edges out from whatever it found. github.com/muvon/octocode, Apache-2.0, single Rust binary.

The problem: plain RAG over code retrieves chunks that sound similar and has no idea that auth_middleware.rs imports jwt.rs and is wired into router.rs. The agent gets a plausible snippet with no structure attached. octocode gives it semantic search plus the import/call graph, signature views so it can see a file's shape without reading the whole thing, and go-to-definition through your language server.

Speaks MCP, so it drops into Claude Code, Cursor, Windsurf or Claude Desktop.

The feedback I actually want is whether the graph earns its keep against just letting the agent grep. My honest read is that grep wins on small repos and loses once the question is "what breaks if I change this", but I would rather hear where that does not hold than be told it is great.

1

u/gandazgul 1d ago

Hey check out this project: https://github.com/1broseidon/cymbal a simple and fast cli instead of MCP.

1

u/gandazgul 1d ago

I’m working on RunWield, a tool for planning and coordinating AI-assisted coding work.

The short version: AI coding tools are great at generating code, but the surrounding workflow still gets chaotic fast. Once the task is bigger than “change this one function,” you need to manage context, decisions, implementation steps, review, and follow-up.

Most of that currently lives in a mix of chat threads, scratch docs, issues, and memory. RunWield is meant to give developers a better workspace for that process: plan the change, preserve the reasoning, coordinate AI-assisted implementation, and keep the work understandable enough to review and trust.

It’s for experienced developers using AI coding tools, especially people doing larger refactors, feature work, or multi-step changes where context and correctness matter. Right now I’m looking for early feedback from people who already use Claude Code, Codex, Cursor, Aider, or similar tools and have strong opinions about what breaks down in the workflow.

I’m the founder/builder, so this is my project.

Signup / feedback link: https://runwield.dev and https://github.com/gandazgul/runwield

1

u/lamchun1110 1d ago

I use several AI coding subscriptions, and I was tired of opening separate dashboards just to find out how much quota I had left and when it would reset.

So I built UsageDeck, a free and open-source tray/menu-bar app that puts those details in one place.

It currently supports 13 providers, including Claude Code, Codex, Cursor, GitHub Copilot, OpenRouter, Devin, Grok, Kimi, MiniMax, Z.ai, and others.

It shows:

Current usage and remaining quota
Reset times
Whether your current usage pace will last until the reset
Token history and estimated spend
Optional low-quota notifications
Multiple accounts for supported providers

It runs on Windows, Linux, and macOS.

Privacy was important to me: there’s no UsageDeck account, backend, analytics, or telemetry. It reuses provider logins already stored on your computer, stores manually added API keys in the OS credential store, and communicates directly with the providers.

It’s free and MIT licensed.

Website: https://usagedeck.app
Source: https://github.com/lamchun1110/UsageDeck

I’d appreciate honest feedback, especially:

Which provider or metric is still missing?
Does the local-credential setup feel clear and trustworthy?
Would you prefer quota remaining or quota used as the default view?

For transparency, UsageDeck began as a fork of OpenQuota and has since become an independent project. The full project lineage is documented in the README.

1

u/socleads 1d ago

Built SocLeads.com I am affiliated. It pulls biz leads and contact details from Google Maps and social sites so you stop doing copy paste list building. Want feedback on data accuracy and what exports or fields you need most.

1

u/Desperate_Sir1087 1d ago

Hi folks! I've spent some time building a developer tool that lets coding agents subscribe to real-world events through one simple broker: agent-message-broker (amb). Github: https://github.com/bitnahian/agent-message-broker

The pitch: coding agents are batch processes. You prompt, they run, they stop. But most of what an agent cares about (a ticket moved, a PR opened, a doc changed) happens between prompts. amb wires event sources (Jira, GitHub, Google Drive/Docs, any polled URL, generic webhooks) to topics, and you subscribe live agent sessions to those topics. When an event lands, the broker pushes it into the running session, so the agent reacts in the same conversation it's already having. No per-agent background scripts or polling.

I recorded a demo showing the full loop across 2 agents and 3 vendors:

A pi coding agent is subscribed to two topics: one watching a Jira board, one watching a Google Doc.
When a ticket is pushed to In Progress, pi gets the event but waits. The implementation details are going to land in the Google Doc.
The doc update comes through as a second event, pi picks up the spec and implements the ticket, then I prompt it to raise a PR.
A Claude agent is subscribed to a third topic with a GitHub source watching for PR events. It sees the new PR and reviews it.

One thing worth noting: none of this had to go through the UI. Everything (topics, sources, subscriptions, session discovery, event inspection) is available via the amb CLI, so agents can wire up their own subscriptions. The UI is more for live viewing, orchestrating and following along: watching events flow between sources and sessions in real time.

Everything runs locally (Node 22.5+, SQLite, no cloud component), polling is the baseline so nothing needs to be internet-reachable, and webhooks are an optional opt-in tier.

It's on npm. Try it without installing:

npx agent-message-broker          
# broker + UI at http://127.0.0.1:4733

Or install it globally for everyday use (gives you the amb and amb-server commands):

npm install -g agent-message-broker

Here's a full quickstart: point a pi session at a Jira board and a Claude session at a repo's PRs. One-time credential setup first:

amb config init --kind github     
# then drop your PAT into ~/.amb/github/credentials.json
amb config init --kind jira       
# then fill ~/.amb/jira/credentials.json (email, apiToken, domain)

Then wire the topics (broker running in another terminal):

# topic watching a Jira board for tickets moving to In Progress
amb topics create jira
amb sources create --topic jira --kind jira --options '{
  "jql": "status CHANGED TO \"In Progress\" AFTER -30d ORDER BY updated DESC",
  "intervalMs": 120000
}'

# topic watching a repo for PR events
amb topics create prs
amb sources create --topic prs --kind github --options '{
  "repo": "owner/repo",
  "eventTypes": ["PullRequestEvent"],
  "intervalMs": 60000
}'

# start the pollers (create prints the source id)
amb sources start <sourceId>

# subscribe live agent sessions so events push mid-conversation
amb sessions                                                  
# discover running sessions
amb subscriptions create --topic jira --agent pi --session <sessionId>
amb subscriptions create --topic prs --agent claude --session <sessionId>

Watch events land in real time in the UI at http://127.0.0.1:4733, or inspect from the terminal:

amb events list --topic jira

Google Docs/Drive/Sheets work the same way via amb google login (OAuth consent once, then the broker acts as you). More recipes in the README.

Would love feedback. What events would you want your agents to react to?

https://reddit.com/link/p6zsiig/video/08f2mgkz7qmh1/player

1

u/informity 1d ago

Informity AI — open source local document chat and translation for Mac, source-cited answers

Built and open sourced a Mac app for local document Q&A and translation. Index your files, ask questions across all of them with source-cited answers, or translate documents locally. Everything stays on your machine.

PDF, Word, Excel, PowerPoint, EPUB, Markdown, scanned PDFs (OCR) and more
Researcher mode: corpus-wide RAG with source citations
Assistant mode: single file or open-ended chat
Document translation: tone selection, quality scoring, export to Markdown or plain text
Models: Qwen3.6 35B A3B (default), 14B and 9B for lower-spec machines, Ollama support for any model you prefer
No cloud, no accounts, no fees

MIT licensed, fully open source.

https://www.informity.ai | https://github.com/informity/informity-ai

1

u/Specialist_Fail2939 1d ago

I noticed something annoying: every commit Claude Code helped with had this quietly appended to it:

Co-Authored-By: Claude noreply@anthropic.com

One trailer is all it takes — GitHub parses it and permanently lists the AI as a **contributor** on your repo. The only way to undo it after pushing is rewriting history and force-pushing. And it's not just Claude — Cursor, Copilot, Codex and Gemini all do their own version of this.

So I made **Ghostwriter** 👻 — *your AI does the work, your name signs it.*

It's a Claude Code skill that triggers on any git/GitHub write operation and enforces:

- No AI `Co-Authored-By` trailers — ever (including amends, rebases, squashes, merges)

- No "🤖 Generated with Claude Code" footers on commits, PRs, issues, or releases

- Author/committer is always *your* git identity

- A self-check grep before finishing any commit, so nothing slips through before push

- Human co-authors are kept — only AI self-credit gets stripped

It also ships a portable rule block for other tools (Cursor, Codex CLI, Copilot, Gemini CLI, Windsurf) with a table of exactly which file to paste it into for each one.

Bonus tip even if you don't install it — the trailer is actually injected by a Claude Code *setting*, so kill it at the source in `~/.claude/settings.json`:

{

"attribution": { "commit": "", "pr": "" },

"includeCoAuthoredBy": false

}

The skill then covers everything the setting can't reach (hand-written PR bodies, amends, other tools).

Repo: https://github.com/cd-ndk/ghostwriter

Install is just a clone into `~/.claude/skills/` — details in the README. If this saves your contributor graph, a ⭐ on the repo would mean a lot. Feedback and PRs welcome (they'll be authored by you, not your AI 😄).

1

u/Either-Win-862 1d ago

I built an open-source coding agent that uses a code graph to reduce context, cost, and search time

GitHub:
https://github.com/JibanKumar-cloud/faber

npm:
https://www.npmjs.com/package/faberwright

Your coding agent shouldn’t need to read your entire codebase to understand it.

That’s the idea behind Faber, an open-source AI coding agent for the terminal.

Faber uses a code graph to find relevant files and symbols first, instead of repeatedly scanning large parts of a repository. That means less unnecessary context, faster codebase navigation, and lower repeated API costs.

Main features:

Claude, OpenAI Codex, Local model integration
Code-graph-guided repository exploration
Prompt caching to reduce repeated input cost
Token-conscious (Chain-of-Draft style) output to reduce unnecessary generation
Git-aware workflow with change detection, optional per-task commits, /undo, and /redo
Expenditure tracking for calls, tokens, cache usage, cost, and estimated savings `/usage`

The goal is simple: understand more of the codebase while reading and spending less.

Prerequisite:
It requires Node.js 22.5 or newer because it uses Node’s built-in SQLite support.

Install:
npm install -g faberwright

Then, inside your project:
faber

Medium article:
https://medium.com/@jshial25/why-should-an-ai-coding-agent-read-hundreds-of-files-to-answer-one-question-d6369d29dfa5

1

u/Street-Chest2270 1d ago

Disclosure: I maintain FreshCtx, a free Apache-2.0 Python project.

The failure I am trying to make testable is an AI coding agent reading a branch, deployment manifest, approval or API response, then reaching a tool call after that evidence has changed. FreshCtx re-checks only the dependencies the application declared and blocks the tool before its body runs when the evidence is stale or unverifiable under policy.

v0.5.0 adds optional sync and async hooks for Agno 2.9. The core remains model-neutral.

Install: pip install 'freshctx[agno]==0.5.0' Example and release: https://github.com/Hyperwise-LLC/freshctx/releases/tag/v0.5.0

The specific test I would value: have an agent read a deployment target, change that target before execution, and tell me whether the hook blocks the actual tool body cleanly in your workflow.

1

u/Fair_Royal_6816 1d ago

I built Knoku.

It gives coding agents access to docs and internal knowledge through MCP.

You can connect GitHub, Notion, Confluence, Jira, OpenAPI docs and other sources. Knoku indexes them and returns cited answers.

I mainly built it for teams where half the useful context lives outside the repo.

Would be curious to hear if anyone here would actually use this with Claude Code.

https://knoku.com

1

u/The_guy_withnolife 1d ago

Axiom is a Windows-first AI workspace I built for AI-assisted coding workflows. It combines local GGUF inference, self-hosted OpenAI-compatible endpoints, and optional OpenRouter behind one interface, with attachments/vision, code execution, artifacts, and local persistence. The Workplace Council runs Architect → Builder → Critic, with a Single Model mode for comparison.

I used AI coding assistance during development, but I’m responsible for the architecture, integration, testing, and product decisions. It is a free Windows app; the source is source-available under CC BY-NC-ND 4.0, not OSI-licensed open source.

Repo: https://github.com/YoMosa2009/Axiom

Release: https://github.com/YoMosa2009/Axiom/releases/tag/v1.8.6

I’m looking for specific feedback on which parts of the workflow help when building with AI coding tools, and where model/tool limitations should be clearer.

1

u/nez_har 19h ago

VibePod is a lightweight CLI that spins up any agent inside sandboxed Docker/Podman environments with zero configuration.

Multi-Agent Support: Run Claude Code, Codex, Antigravity, Copilot, Pi, and others via one unified command.
Isolated & Safe: Sandboxed containers keep your host system clean and protected.
Built-in Local Analytics: Built-in proxy captures API traffic and token usage with a local web dashboard (vp logs start).
100% Local: No cloud telemetry—your code, logs, and keys stay on your machine.

Install & Run: bash pip install vibepod vp run claude

Website: https://vibepod.dev
GitHub: https://github.com/VibePod/vibepod-cli

Feedback and feature requests are welcome!

1

u/eatsleepliftcode 17h ago

I built **HarnessCheck** because I was tired of comparing coding agents by vibe, screenshots, and one-off demos. Small config/runtime changes kept changing repo outcomes, and I wanted a repeatable way to see it.

What it does:

- same fixture, same task, same assertions across agents

- fresh copied workspace per trial for mutation isolation

- assertions for regular files, content, stdout/stderr, commands, and changed-file allowlists

- JSON / HTML / JUnit / Markdown reports for local runs or CI

- works with Codex, Claude Code, Gemini CLI, OpenCode, or a custom wrapper

Important caveat: this is **not** an OS/network sandbox. The isolation is “fresh copied workspace per run”; the actual permission boundary still comes from the underlying agent runtime.

It's MIT-licensed OSS: https://github.com/SiluPanda/harnesscheck

I'd especially love feedback on missing assertion types, adapter defaults, CI ergonomics, or places where the harness/runtime boundary is still confusing.

1

u/suryadeeppal 17h ago

I’m the developer of PRamatic, a completely free pull-request review inbox for macOS.

What I built: one place for review requests, moved PR heads, findings, conversations and local draft comments.

Problem it solves: I was spending too much time reconstructing review context across GitHub tabs before I could even start reading the code.

Models/tools: reviews can run through Codex or Claude Agent. The user chooses the provider, model and reasoning level.

Who it’s for: developers who review GitHub PRs regularly but don’t want an AI agent posting or changing anything automatically.

GitHub access is read-only, and suggested comments are copy-only drafts. Reports stay on the Mac; selected review context goes to the provider chosen by the user.

Mostly I’m looking for honest feedback. Do other developers deal with the same scattered PR context, or did I build a very specific cure for my own tab addiction?

https://pramatic.app

1

u/kc_ramakrishna 8h ago

This is a recipe/guide to make your codebase agentic ready. This is aimed at Engineering teams but benefits will be seen in smaller codebases as well.

Will significantly reduce hallucinations, increase accuracy and improve token efficiency.

https://github.com/Nistapp/codebase-agentic-readiness-framework

Feedback welcome and will be incorporated as and when possible.

1

u/OscarV4 8h ago

Hey, I’m a student in Korea. I’ve been vibe-coding an open-source Codex plugin that turns messy notes and screenshots into Apple Reminders.
It runs locally on macOS, with an Open Minis skill for mobile use too.
Still learning and sanding it down, so honest feedback or contributions would mean a lot:
https://github.com/Oscar-V4/apple-reminders

1

u/thegreatdaveedllc 2h ago

I built a free browser-based MCP security risk scorer + prompt-injection regression-test generator after looking at how quickly MCP tools can turn an LLM security issue into an actual permissions/action problem.

The free tools are aimed at people building AI agents that use MCP, RAG, external tools, sensitive data, or write actions.

The risk scorer looks at things like:

high-impact tool permissions
arbitrary command execution
human approval gates
server-side schemas
scoped credentials
egress restrictions
MCP isolation
attributable tool-call logs
indirect prompt-injection regression testing

I also made a second free tool that generates a safe, non-destructive prompt-injection regression plan based on the architecture you're using.

Free tools: https://mcp-security-launch-kit.vercel.app/

https://mcp-security-launch-kit.vercel.app/prompt-injection-test/

There is also a $12 paid download with the larger 45-control audit workbook, 24 regression scenarios, permission/evidence matrices, launch gate, incident runbook, and policy starter.

Disclosure: I built and sell the paid kit.

I'd especially like feedback from people actually shipping MCP-enabled agents: which security check is missing, unclear, or something you already test differently?

0

u/Other_Poetry_5243 1d ago edited 1d ago

Hi! I built https://getwebstack.com/, a tool that creates parallel ephemeral environments for coding and live testing complex multi-service web apps. (Docs: https://getwebstack.com/docs/use-cases/ai-sandboxes/)
Problem: AI coding agents can write code in isolation (with worktrees), but they can't run it in an easy way so they can test the code as a dev does.
Tools: The tool is built around Docker and Kubernetes to ensure full isolation and even prod parity.
Who is it for:

devs who work on complex solutions (using microservices architecture) that develop, code-review, or test features in parallel or who want to switch fast from one to another.
QA engineers who are spending too much of their time creating testing environments.

Feedback: I know for some devs, worktrees & code isolation is sufficient, but I want feedback for those who are struggling to isolate the app at runtime, meaning: data isolation, ports, services, URLs, queues, etc.

1

u/gmara13 1d ago

Links broken

1

u/Secret_Dress8930 53m ago

Affiliation: I built this.

I just released an early free alpha of Foreman, a macOS control/verification layer for Codex.

The problem I was trying to solve is that coding agents can be extremely capable while still saying “done” before the actual product satisfies what the user asked for.

Foreman sits between the user and Codex.

The user describes what they want normally. Foreman preserves that original intent, generates a more structured engineering task, supervises the Codex session, translates the technical activity into understandable progress, and then independently verifies the resulting project.

If verification fails, Foreman generates a focused repair task, resumes the same Codex workflow, and verifies again within bounded repair limits.

The important design rule is:

The coding agent does not grade its own homework.

Current verification includes shell, filesystem, process, HTTP, and native macOS Accessibility checks, plus regression detection, checkpoints/rollback, verifier anti-tamper, and final full-contract verification.

Current stack:

macOS / Swift
Codex CLI integration
local deterministic verification
Apple Silicon currently

Who it’s for:
People using coding agents who want more confidence that the actual requested result works, especially people who aren’t experienced enough to manually inspect everything the AI writes.

It’s very early and free. I’m mainly looking for people willing to break it.

https://tylerpcaldwell-gif.github.io/Foreman/

Most useful feedback:

false verification
confusing onboarding
repair loops that behave badly
places where Foreman misunderstands the original request

Discussion Weekly Self Promotion Thread

You are about to leave Redlib

A harness and agentic IDE

I built an open-source coding agent that uses a code graph to reduce context, cost, and search time