I built an open-source MCP bridge that lets ChatGPT inspect one local repo without shell access
github.comu/Lucaslogged — 8 hours ago
r/devtools
Announcing the Code-Infrastructure-as-Code (CIaC) compiler: one source file, five language targets, whole-system simulation, no (required) infrastructure
Hi rustaceans,
I recently designed the Code-Infrastructure-as-Code (CIaC) compiler, a command-line development tool (written predominantly in Rust) for a declarative DSL that can describe an entire service system in at least one file.
CIaC treats .ciac files as the architectural source of truth and compiles into Rust, Python, TypeScript, Go, and/or Java. Real deployment artifacts can also be generated: compose, Kubernetes, Terraform, or CI.
All that you're expected to do is declare the system specifications and the compiler handles the rest. External handlers are seeded once for injecting your own code and never overwritten, whereas inline handler bodies, such as the ones in the examples below, are compiler-owned and regenerated every build.
Why does this exist?
Put simply: to increase backend development speed and service reliability for both humans and agents.
As for myself: I initially created this tool for my own usage, as I spend a lot of time experimenting with infrastructure and building out services to serve domain-specific requirements. In other words, I got tired of building and maintaining services myself so I concocted a solution.
A technical perspective
A .ciac file describes a system as a set of declarations consisting of records, APIs, pipelines, streams, and workers.
Here's a single service example (event-pipeline):
// A single-service event pipeline
//
// A public API validates and publishes, a worker
// consumes and persists, and `events` is a shorthand
// that expands into its own chain of queue -> worker -> storage.
service Ingest;
use {
db Postgres;
queue NATS;
}
api Submit;
worker Processor;
events PageView;
pipeline Submit:
Validate
-> Queue
-> Return;
pipeline Processor:
Enrich
-> Store;
Here's a multi-service example (sim-three-service):
// Three services, one request
//
// `Intake` synchronously calls `Billing` and gets
// a real response, then publishes an event that
// `Fulfillment` can react to independently.
//
// This represents a synchronous call, an async stream,
// and independent storage ownership by each service.
project ThreeService;
record Order {
id: Uuid;
total: Float;
}
record ChargeRecord {
id: Uuid;
order_id: Uuid;
amount: Float;
}
record Shipment {
id: Uuid;
order_id: Uuid;
}
stream OrderAccepted: Order;
service Intake {
use { queue NATS; }
api SubmitOrder: Order {
method: POST;
path: "/orders";
}
pipeline SubmitOrder:
call Billing.Charge
-> publish OrderAccepted
-> Return;
}
service Billing {
use { db Postgres; }
table Charges: ChargeRecord;
api Charge: Order {
method: POST;
path: "/charge";
}
handler RecordCharge(order: Order) -> Order {
db.insert(Charges, ChargeRecord { id: Uuid.new(), order_id: order.id, amount: order.total });
return order;
}
pipeline Charge:
RecordCharge
-> Return;
}
service Fulfillment {
use { db Postgres; queue NATS; }
table Shipments: Shipment;
worker Ship on OrderAccepted;
handler RecordShipment(order: Order) -> Order {
db.insert(Shipments, Shipment { id: Uuid.new(), order_id: order.id });
return order;
}
pipeline Ship:
RecordShipment;
}
Today's capabilities:
- Compile into five language targets - Rust, Python, TypeScript, Go, and/or Java.
- Thirteen infrastructure capabilities identically implemented across all five targets.
- Simulate the whole system deterministically, in-memory, no Docker required.
- Architecture changes can be classified, renamed, or migrated safely.
- A usable LSP and an MCP tool surface for agents.
Today's limitations, for now:
- Many-to-many
Reference<T>fields type-check properly, but the generated API can't read or write them yet. - No field-level validation; handler logic enforces business rules instead.
- Destructive schema changes are refused; those must be written by hand.
- With no path onto an existing codebase, CIaC is for greenfield systems only.
You can learn more about the language itself in the docs. There are plenty of other examples as well.
AI Disclaimer
Needless to say for software development (AI-assisted development especially), it is in the best interest of any software project to be heavily curated throughout its lifetime.
I made sure to use gen AI tools for the implementation deliberately; I carefully hand-crafted a high-level language for combining arbitrary backend service components into coherent and simulation-verified codegen artifacts.
Over the course of the project's development, I committed to regular code reviews and testing to ensure the AI-generated code is up to par with my standards as a maintainer.
To help with maintenance, there are fleshed-out test and benchmark suites for both the compiler and codegen artifacts. These have been run prior to each release since their inception.
If you're interested in making additions or changes to the project (with AI or not), all I ask is that you hold yourself to similar review and testing standards.
Get involved
You can learn more about how to use CIaC from this discussion thread.
Additionally, you can install the compiler from here, or follow the readme instructions instead.
Feel free to take a look around the project, try it out, open issues/PRs, and ask any questions you may have. I'm more than happy to discuss the project!
Collaboration and constructive criticism are welcomed!
u/Mundane_Business3419 — 8 hours ago
What is the next IDE?
I am just thinking: now that agents basically create over 99% of all the code I need, what does an IDE in 2026/2027 actually need to deliver? For me it would be a simple yet powerful visual diff to review changes and give feedback. Preferred locally instead of github / gitlab or whatever you use. Maybe a simple way to merge pull requests. But then: Is there actually much more that you would need in the future when agents write all the code?
u/Seeb83 — 13 hours ago
I am building a Git GUI that shows you what is happening under the hood. 👀
You click an action → see the Git command → see what changed.
There’s also a Learning Mode for beginners with interactive practice and real Git scenarios.
Here’s a quick demo of what I’ve built so far 👇
This is just a quick demo, not the full app. I’ll be adding the rest of the Git commands and more features before the first release.
The project will be open source, and I’m hoping we can keep adding to it and turn it into a useful Git tool for everyone.
Still early, so I’d love to hear your feedback.
u/WeakWoodpecker2912 — 1 day ago
I built an MCP server that lets your coding agent read its own past runs and light up a graph as it answers (free, MIT, local)
Disclosure up front: I built this. It's free, MIT, and shipped (npm: rungraph).
Claude Code and Codex CLI write full session transcripts to disk, and rungraph reconstructs them into interactive run graphs. The MCP server is the part this sub might find interesting: npx rungraph mcp --install gives your agent tools over its own history. list_runs, get_graph, find_nodes, get_detail, focus_nodes, get_current_view, open_visualization.
The design problem was context size. A real 176-node run is about 20k tokens as a full graph, 13.5k in the compact projection, and 1.1k through find_nodes. Narrowing beats projecting, so the tool descriptions steer agents to find_nodes first, then get_detail for one node's actual error text.
The fun tool is focus_nodes. You ask Claude in your own terminal "why did the Edit on token.js keep failing", it answers there, and the dashboard you have open lights up the exact nodes the answer is about, then returns a deep link that restores the same highlight against that dashboard (or a bundle the recipient has open). Honest limitation: with no dashboard watching, the call still succeeds and just reports that the highlight was skipped. The read tools parse straight from disk, so they work with no server running at all.
Implementation note for the protocol nerds: the JSON-RPC transport is hand-rolled over stdio because the package has zero runtime dependencies, which keeps the npx install tiny. If more than one dashboard is live (yours, plus a bundle someone sent you), list_runs merges them and every other tool routes by run id.
Live Demo: https://fayzan123.github.io/rungraph/
Repo: https://github.com/fayzan123/rungraph
If you wire it into a client other than Claude Code, I'd like to hear whether the tool descriptions hold up
u/Express-Phase1532 — 1 day ago
HAR – Open source harness for building multi-agent coding workflows
Hey everyone!
Over the past year, as I tried to scale our agentic coding workflows and software factories at my company, I kept hitting the same set of problems. So I built HAR to solve them.
Repo: github.com/os-factory/har
Getting a single coding agent to work in a repo is easy. Scaling to a real multi-agent workflow, where several run at once and where you verify and trust the output, is where it breaks down. A few things go wrong:
- No standard way to run or verify a repo. That knowledge is scattered across a README, a CLAUDE.md, editor rules, and CI config, all drifting out of sync with each other and the actual code.
- Agents on one repo collide. Shared dev server, shared database, shared ports, conflicting git state.
- Trusting a change means re-verifying it yourself. Which defeats the point of running a fleet.
- Vendor sandboxes lock you in. If the setup lives in someone's hosted dashboard, switching agents later means rebuilding the whole thing.
What HAR does
HAR is a CLI and an MCP server. It works with Claude Code, Cursor, Codex, or any MCP agent, and it closes each of those gaps:
- Isolation. Each agent gets its own git worktree, branch, ports, and database. Nothing is shared with the main checkout or another agent's slot, so a fleet runs in parallel without colliding on a dev server, DB, or ports.
- Deterministic validation gates. HAR runs your project's real checks through a fixed pipeline, same result every time. The result is bound to the exact code that passed and enforced at commit time, so an unverified tree cannot land.
- Verifiable proof. Every run leaves logs, artifacts, and a validated tree hash tied to the exact code checked. A reviewer inspects the evidence instead of trusting the agent's self-report.
- Full observability. Mission Control is a local dashboard showing every repo, worktree, run, and validation in one place, so you can watch a whole fleet as it works.
All of this lives in one contract committed to your repo, which every agent reads the same way. It replaces the usual scatter of a README, a CLAUDE.md, editor rules, and CI config that drift apart. You start from a profile that matches your stack, your agent adapts it to the real repo, and you extend verification with plugins (like Playwright) or with any command you already run.
Give it a try and let me know what you think :)
u/Fluffybaxter — 2 days ago
Tome – a security first desktop cockpit for coding agents
Hello everyone, long time lurker here. Firstly I would like to thank you for taking the time to read my post and (hopefully :) ) taking a look at my project.
Tome is a desktop app (macOS + Linux) that puts your coding agents (claude, opencode, pi), terminals, editors, and an AI assistant into one tiling workspace with a sandbox around the agents.
a short video showing how you can make loops or graph engineer using the flow tool
I use Tome everyday to orchestrate agents, build flows and generally learn new technology whilst building projects. One of my favorite features, "verbose mode", teaches the user how what they've built actually works before pushing to remote repos.
The part I think is actually different: agents run inside a containment cell, an OS sandbox (sandbox-exec on macOS, bubblewrap on Linux) whose only route to the network is an allowlisted loopback proxy. It's a boundary you can see and unlock on purpose. Every unlock and blocked host lands in a security event log.
New in v0.4.0: voice. Fully on-device transcription (Apple Speech on macOS, whisper.cpp as the offline fallback) — streaming, hands-free, and audio never leaves the machine. Talk to the assistant, talk over it to interrupt, and it answers back.
Also in there:
- An assistant that can list/read panes and type into terminals (auto-run is off by default)
- Flows: DAGs of agent nodes
- Mentor mode, an in-app git UI, a note vault ("brain"), workspaces
- MIT, macOS + Linux (the DMG is unsigned for now)
GitHub: https://github.com/zwaneldmz/tome
Release: https://github.com/zwaneldmz/tome/releases/tag/v0.4.0
I'd especially value feedback on the security model and the voice UX, those are the two things I think were hard to get right.
Once again thank you for your time!
u/GrimmGun — 1 day ago
Try Benzi- A coding agwnt that _queries_ your codebase instead of reading it
Benzi is a compiler + runtime tracer + harness and Al agent built to understand code from ground up. Challenging traditional RAG and embedding space approaches, Benzi aims to write code as cleanly as it understands it.
77.4% SWE-bench Verified (#4 on the leaderboard) for less than $30. (using deepseekv4flash. Benzi is model agnostic)
Also included in the benchmarks page is proof for mechanism that makes this possible.
Any feedback is greatly appriciated!
u/DonkeyTheKing — 2 days ago
I made revera, a tool that scores NPM packages before you blindly install them
So I wondered sometimes, how little info we have when we install NPM packages.. so I built revera... its a npm package scorer, but on steroids. It uses a complex sophisticated algorithm (still not perfect, but near-perfect) that nails at ranking NPM packages.. it gives every package a score and the score is determined on criterias such as maintainability, trust, package releases, downloads, much more..
the audit command scans the working directory for
it has the following extra features:
- logging in with github for higher rate limits
- why command for explaining a certain package's score
- doctor for checking if everything is working
- caching system which lives for 24h on local machine
- and a customizable config
It would mean the world to me if you all could try it out and give feedback (bad or good)!
github repo: https://github.com/aaravmaloo/revera
npm package page: https://www.npmjs.com/package/@aaravmaloo/revera
u/aaravmaloo — 1 day ago
I made a github readme card that works like a heartbeat monitor. it flatlines if you stop committing
https://github-pulse-topaz.vercel.app
been building this for the past couple days. it's a little card for your readme that draws your commits as an EKG. it beats faster when you ship, fades when you rest, and if you disappear for two weeks it literally flatlines. come back and it stamps REVIVED on you.
some fun stuff in there — your blood type is your main language (mine is TS+)
one line of markdown, no login, free:
repo: https://github.com/pouyashahrdami/github-pulse
hope you guys use it and enjoy it. it's open source and contributions are always welcome, would love to see what you add to it :)
u/Ok-Anywhere4442 — 2 days ago
I built Tieline so my agents can understand the product, not just the code
With codebase wikis, most are written more from an engineering lens, explaining how the code works without explaining why it should work that way.
I wanted to connect business intent directly to its implementation using language that nontechnical people already use. I've been experimenting with creating my own software factory, and wanted a way for myself and all my agents to 'speak the same language', with a clear 'contract' on how specific features should work. I built Tieline so all my agents can work from the same product contract, even if they do not have access to the codebase.
Tieline generates user stories and acceptance criteria, then links them to the code and tests that implement them. This lets an agent answer questions like:
- What is this feature supposed to do?
- Which code and tests implement it?
- Which behaviours might this change impact?
Tieline also builds a static topology graph of the codebase. When code changes, it can trace the possible impact through that graph and connect it back to the relevant acceptance criteria.
This creates a product-level blast radius. It does not claim that something will break. It gives the agent and reviewer a shortlist of behaviours that may need another look.
Tieline generates the initial product contract for you to review. After that, it checks pull requests and proposes updates when the implementation changes.
On top of tracking current product state, Tieline lets you track feature requests, bugs, and ideas as Observations. The accepted production contract lives in the repository and can be synced to Postgres, while Observations stay in Postgres, accessible by all your agents via MCP.
Agents without codebase access can query this information through MCP, allowing coding, product, research, and support agents to work from the same accepted product state while also seeing where the product may be going next.
While experimenting, the unexpected benefit has been identifying quick wins. While working one feature, I'll ask my agent to check the backlog. Semantic search finds related items that fit naturally into the current work and fits them in the PR.
Still experimental, but my goal is to make the repository the reviewed source of truth for product behaviour, then make that contract available to every agent, not only the engineering ones.
Open source project: https://github.com/knoxgraeme/tieline
Would love any feedback or to hear how others are thinking about these problems!
u/barginbinlettuce — 2 days ago
Yrkit – Code from Anywhere
Hey, everyone. I am Matheus Araújo, from Brazil, and I have been building Yrkit for the last few years. It is an IDE that works on the cloud currently - I have plans for it -, and has some cool features: live preview, code editor, console, elements (like devtools), terminal, ssh, kanban, drop-and-drop, ai, and other tools.
I still don't know how to distribute it, and I still have no one using it except myself - I use it daily for my clients' projects -, and I would like your feedback.
Yrkit is a dream of mine, I always wanted to have an IDE that I build myself, as well as a programming language that operates with it - yr, at https:yr-lang.org. It is a working product, I already launched it, and I am experimenting marketing and distributing, but I would really love your feedback.
For me, it works because I can code from anywhere, and it is perfect for JS and Node. I code from my phone, wherever I am at, and, if I have to do some things in the terminal, I can access it directly, ou go through my computer and run the actions that it created. It generates artifacts in html, css, js, bash, python, etc.
I still don't know how to pass that idea to other people, or how to talk about this project, but I would really love some feedback, and I would love to have someone else using it.
I appreciate all feedback.
Matheus Araújo
u/No_District_2708 — 2 days ago
Built a small observability tool, looking for beta testers
Got tired of juggling separate tools for uptime, traces, errors and logs, so I built one that does all of it without being a pain to set up. SDKs for Go, TS, Python, Rust, plus a host agent that explains why an incident happened instead of just dumping graphs.
Still rough around the edges. Looking for a few people to try it and tell me what's broken. Link in the comments.
u/reida_1 — 2 days ago
Code review that follows callers across you repos
Started with our own review queue. Most of the code in a PR is generated now, so PRs land faster and bigger than anyone reads properly. First thing that goes is context outside the diff. Nobody opens the other repo to see who calls the function you just changed. Skim, approve.
So we automated that part. It resolves the symbols the diff touches, walks the callers through a code graph, and pulls in how your repos connect: routes, queues, shared tables, package deps. Sub-agents for architecture, security, logic, tests. One review comes out.
Weak spots: GitHub only, no benchmark, noise tuning needs work. Free tier is one repo crawl plus your first reviews, no card.
If you try it: what fraction of the findings would you have acted on?
u/LOSIHOIDAANACCOUNT — 3 days ago
i made a secure way for agents to request secrets from you using HyperDHT
Hi all,
I kinda got sick of having to give secrets to my agents and all the potential leakage in the pipeline (with the harness, the model router, the model provider, the training set, the chat application etc etc) so I decided to make peardrop.fyi - this tool allows your agent to declaratively generate secret request pages/links which you can fill in via web or CLI. The agent can determine a script that runs once the values are received or can put them in a target folder. This is useful if you want to put something in your machine vault/keychain without either giving access to the credentials or the browser to the agent.
here is the repo: https://github.com/smashah/peardrop
(cli, core and self-hostable relay are all open source)
u/Plastic-Trip-2778 — 3 days ago
Honest and Brutal Reviews on our Product Please .... !
I've been building Pinaka on the side for the past few months — an AI agent that automatically writes root cause analyses when a bug ticket is filed.
The problem it solves: every time a production bug hits, a senior engineer spends 2-3 hours investigating before writing a single line of fix. The actual fix takes 20 minutes. The investigation takes the rest of the day.
Pinaka eliminates that investigation step. Tag a Jira ticket or mention @pinaka-app on a GitHub Issue — it reads your indexed codebase, captures runtime context via an SDK, and posts a structured RCA as a comment. Root cause, exact file, exact line, fix approach. Automatically.
What I've validated so far
Ran it against real open source bugs:
- BullMQ issue #2487 — code only scored 6.5/10, code + runtime context scored 9.2/10 against the actual merged fix
- Prisma ORM issue #29480 — open bug, no ground truth, diagnosed from behavioral contrast across test files
- Pinaka's own Java SDK — found a real ForkJoinPool exhaustion bug, fix shipped same day
All three write-ups are public, including the limitations.
What I'm looking for
couple of engineering teams (2-150 engineers) using GitHub who want to try this on a real production bug. Free, no commitment. I'll personally onboard you and be available for any questions.
Works with Jira and GitHub Issues. No Jira required. One OAuth click to connect. First 5 RCAs free.
Honest state of the product
No paying customers yet. Building in public. The product works — the benchmarks above are real — but I need real teams on real codebases to validate it beyond my own test cases.
If this sounds useful for your team, drop a comment or DM me. Happy to show you a live demo on your repo.
u/atharvapanegai — 4 days ago
Cottage is a tool for teams to manage age-encrypted secrets in git repositories.
It provides a simple workflow to encrypt/decrypt secrets, manage recipients, and keep secrets out of the repo while still allowing for easy sharing via VCS. Cottage also generates redacted previews of encrypted secrets for better visibility and supports both persistent and temporary decryption workflows, while ensuring secrets are never committed in plaintext.
u/Any-Lack-7699 — 5 days ago
Built architecture intelligence for developers, coding agents, and CI
I'm a software developer (professionally for last 25 years) and got hooked on coding agents as the next guy.
I built https://github.com/enola-labs/enola as architecture intelligence for developers, coding agents and CI. You can see how and what it does as part of CI on that repo itself: https://github.com/enola-labs/enola/actions/runs/30579279230/job/90995180445
I use it daily, and you can add the hook so it does what it is best in: before agent starts editing it uses it to pin the state, after editing is done it checks what it did, so that it can self correct if and when needed.
Me and bunch of friends are using it, and most of stuff I built is based on their feedback and stuff they needed.
Happy to get the feedback from anyone who ends up using it. Also, if the language you need is not there, let me know and I will add it.
u/fairwaycoder — 5 days ago
Nouto: A JSON Viewer for VS Code with tree view, table view, and fetch from URL
I built a JSON viewer extension for VS Code. It allows you to paste JSON, open a file, or fetch directly from an HTTP endpoint, then browse it as a collapsible tree or view arrays of objects as a sortable, resizable table with column pinning and CSV export.
Also has fuzzy search, JSONPath filtering, a query filter language, compare/diff, JSON Schema validation, bookmarks, pinned nodes, embedded JSON detection, and copy in multiple formats (JSON, YAML, CSV, TypeScript, Python, etc). Handles JSONL/NDJSON files too.
Free and open source.
https://marketplace.visualstudio.com/items?itemName=frostybee-dev.nouto-json-explorer
Happy to hear feedback or feature requests.
u/Cheap-Try-8796 — 6 days ago
BigConfig is now Colors
I have renamed BigConfig to Colors. The goal is still to fix DevOps but it was such big improvement over the original version that I have decided to change name. The gist is that you give your agent new skills to create a personal Paas, a K8s cluster, or any piece of infrastructure. The desired state is in YML and every package contains code in Clojure, Python, and TypeScript to reconcile your infrastructure with the desired state. Every codebase has also a SKILL.md so that you can delegate everything to your agent. Any feedback is welcome.
u/amiorin — 5 days ago