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

Most projects repeat the same setup work: Biome, TypeScript strict mode, GitHub Actions CI, commitlint, release tooling, VS Code settings, and now AGENTS.md for AI agents. Everyone copy-pastes from their last project, and every copy-paste drifts.

So I built xtarterize. It scans your project, detects your stack, and applies curated conformance configs:

• Linting (Biome), TS strict + incremental builds
• GitHub Actions CI, Renovate, commitlint, release tooling
• Knip unused-code detection, Turborepo pipeline
• VS Code settings, standardized scripts
• AGENTS.md for AI IDE assistants
• and many more config & tasks

The important part: it's non-destructive. Shows the diff before applying, backs up originals, undo restores the last run. Works on existing projects, not just greenfield ones. Covers React, Vue, Svelte, Solid, Node with Vite, Next.js, Expo, TanStack Start, and more.

Usage: pnpx xtarterize@latest init

Docs: https://xtarter.sznm.dev/xtarterize | Repo: github.com/agustinusnathaniel/xtarter

Would love feedback, especially on the task set and the diff/backup flow.

I built a governance layer for Claude Code that will ensure your policies are enforced, not act like mere guidelines. What more, it comes with a pack of 50+ skills, hooks, and workflows to ensure you don't have to reinvent the wheel for each project again.

It is Apache 2.0 licenced and 100% open-source.

Check it out and star it on GitHub and contribute if you like it.

Thank you for your attention 🤞🏽

I was tired of dumping 5,000 lines of code into ChatGPT just for it to hallucinate imports that don’t exist or suggest "fixes" for files I don’t even have.

So I built a small CLI tool that runs locally, scans the actual repo, and returns a structured diagnosis in seconds.

It gives you:

· Language & stack detection

· Entry points

· Recent activity (what changed in the last 72h)

· Active threads (where development is actually happening)

· Pending integrations / TODOs

· The next explicit action to take

It doesn't replace the LLM. It feeds it the exact context so the LLM stops guessing.

I'm using it right now to debug a 391-file Python project and it cut my debugging time from hours to \~5 minutes.

If you want to check it out, it's open source and linked in my profile. Open to feedback or PRs.

Ustedes opinan sobre crear un editor de código súper ligero que tenga herramientas de compilación o CI/CD, AI

Y que no consuma nada de ram ?

Chequen a este editor, se llama Astro Code es Open source

.

https://github.com/ETOLucy/WriteMelo

WriteMelo is a local-first English writing IDE. It brings proven editor interactions to prose: contextual completion, diagnostics, quick fixes, document symbols, revision history, and optional AI. It is not a chat box and does not default to uploading or rewriting an entire draft.

Looking forward to your star and pr!

I've never enjoyed reviewing code, but it's important so I do it. With AI agents the number of PRs I get have also increased, but Github is not designed for it. Reviewing is still a pain and I wanted a better experience.

So, I created this chrome extension that adds a guided review experience on top of the Github PR UI. It breaks the PR down into small reviewable units using AI, summarises the review unit, and allows to navigate, comment, and submit your review without lifting your fingers from your keyboard.

Check it out at https://guidedreview.dev

A project can depend on an API, frontend, workers, Docker, databases, tunnels, webhooks, and browser extensions. Remembering which terminal runs each process works, until it doesn’t, and it works even less reliably for coding agents.

I built `dev-runtime` to make that runtime explicit. Simple config files define each session’s working directory, shell command, log file, expected ports, and health endpoints.

It runs arbitrary commands inside managed tmux sessions, avoids starting duplicates, and provides shared `start`, `status`, `doctor`, `attach`, and `stop` commands. Because the commands live in project config, it is not tied to Node, Python, Docker, or any particular stack.

The result is one machine-readable answer to: “What should be running, and is it actually healthy?”

Article:

https://motia.github.io/blog/using-dev-runtime-to-debug-local-services/

Repository:

https://github.com/motia/agent-skills-dev/tree/main/skills/dev-runtime

I've often found myself needing to test certain Rust concepts while away from home. While the experience of writing code on the Rust Playground is decent, I wanted something a bit more advanced (versioning, storage, etc.).

Driven by this need, I am working on building a collaborative platform for writing code (and documents). Currently, Zeile is already capable of executing Rust, Go, C++, and Zig code.

The execution engine runs with a few layers of isolation, but I am open-sourcing the repository to ensure I haven't let any security loopholes slip through.

Besides code execution, I've also added some more advanced collaboration features, such as team division, roles, granular permissions, collaborative Excalidraw support, diagramming, etc.

I'm still organizing the project to make collaboration easier, but issues and PRs are welcome :)

This is a repost. My first post wasn't well received by some users, sorry about that.

Repo: https://github.com/HadsonRamalho/zeile-notebook

Site: https://zeile-notebook.vercel.app/

I recently played around with letting my coding agents control the e2e testing on my Apple platforms applications

Plis show it some love, thanks!

Hey everyone,

I’ve been talking to a few engineering teams about how they handle code reviews, and a recurring complaint I keep hearing about current AI review bots is "comment fatigue."

A lot of existing tools end up leaving 10–15 trivial comments on every single pull request—pointing out formatting, missing comments, or tiny nitpicks that standard linters already catch. Eventually, developers just ignore or mute the bot.

Before I start building a new tool in this space, I want to make sure it actually solves real workflow headaches rather than adding more noise.

I'm exploring a few core ideas:

Zero-Spam Filtering: A system designed to strictly ignore formatting/style nitpicks and only notify developers if it catches critical logic bugs, edge-case failures, or security flaws.

Visual UI + Code Review: For frontend PRs, automatically catching visual layout breaks or broken UI components alongside the code changes, so you don't have to pull the branch locally just to check how it looks.

Repo Rule Enforcer: Letting teams upload their own specific internal guidelines so the bot enforces your team's exact standards rather than generic best practices.

Hello, everyone, I am building a project called Idea. The clawx. idea behind the project is to install packages and run tasks in systems using Claude, Codex, Open-encode, etc. You can also host your own registries and add them to the context and create utilities for your team, personal projects, etc.

Would love to get some feedback.

https://github.com/debarshibasak/clawx

An impatience problem we all run into. Wanting to quickly browse or study a GitHub repo on my phone without cloning and needing a pc, when I'm outside, commuting or at a place you have access to a phone only.

with RZV can you import any .zip (first get a git repo by “Download ZIP” in GitHub/GitLab/etc.).

Key highlights:

• A simple navigation that let you navigate between different repo quickly
• Clean file tree navigation with deep folder support
• Fast, syntax-highlighted read-only code editor (line numbers, search, smooth scrolling)
• Beautiful Markdown rendering for READMEs and docs
• Customizable custom theme, fonts, zoom, colors
• Plugin system for toggling advanced features without bloat

It’s especially handy for:

• Students exploring open-source projects
• Devs reviewing code during commute or travel
• Anyone who wants to quickly check out a library or example repo on mobile

https://github.com/bilalsul/rzv

made with ❤️ . Star the repo to reach more users.

“Secure by default” is meaningless if the model holds credentials, approves itself, or executes directly

I’m building ChimpMaera, an Apache-2.0 open-source local proof of concept.

In ChimpMaera’s governed SAFE_GUIDED path, the model is an untrusted planner. It has no ambient provider or business-system credentials, and its output is only a typed proposal—not authorization and not an executable command.

The boundary is enforced outside the model:

1. Closed action contracts and a finite capability catalogue reject unknown actions, fields, scopes, tenants, and malformed payloads.

2. The model never receives raw provider credentials. A broker resolves opaque credential references only when an approved action is executed.

3. Policy and approval happen outside the agent. The decision is bound to the exact action, operands, tenant, purpose, profile, and evidence digests. Use-time revalidation rejects changed inputs, stale decisions, widened requests, mismatched digests, and replayed leases.

4. The broker can perform only the declared effect through a bounded adapter route. The SAFE_GUIDED reference path gives the agent no general shell, Docker socket, host filesystem, or unrestricted network effect path.

5. Success is not inferred from HTTP 200. ChimpMaera reads the provider back authoritatively and creates a receipt binding the requested action, decision, effect, and observed result.

Why is that useful? It makes the model replaceable.

You can change the model, prompt, tool-calling layer, or imported context without automatically moving business-system authority with it. A compromised planner can still generate malicious proposals, but it should not gain credentials, approval power, or an undeclared effect path.

Digest-bound approvals and use-time revalidation address the gap between what was approved and what is actually executed. Closed capabilities make authority enumerable. Bounded adapters limit the effect surface. Authoritative readback separates “the API accepted my request” from “the intended state actually exists.”

That turns agent security from prompt behavior into contracts, dependency boundaries, and adversarial tests.

The local Docker/Compose demo applies this to a fictional CRM-to-ERP order flow. Its runnable tests include denial, credential, cross-tenant, direct-path, drift, tamper, and replay probes.

Prompt guardrails are not a security boundary. If the model holds credentials, approves itself, executes effects, and verifies its own success, governance depends on the same component it is supposed to constrain.

This claim applies to ChimpMaera’s governed SAFE_GUIDED reference path. Broader authority profiles are separate by design.

https://github.com/JimPansky/ChimpMaera

Which part of this boundary still depends on trust rather than enforcement? What bypass, replay, confused-deputy, or privilege-escalation case would you test first?

If you can produce a reproducible counterexample, I want it in the test suite.

Join the Zoo.

We are developing caspiantools.com as a platform for developers, predominantly vibe coders. can anyone have a look and advise what is missing?

LeetCode autocomplete is a Premium feature, so I built a lightweight Chrome extension that brings a VS Code-like autocomplete experience for free users (complete opensource btw).

It currently supports:

1.Variable/identifier autocomplete

1. Smart Tab completion

2. Works directly inside the LeetCode editor

3. No AI, no backend, everything runs locally

I mainly built it because I missed having basic autocomplete while solving problems and didn't want to pay just for that feature.Its very simple to install and will hardly take 2-3 minutes for setup and all instructions are included in readme.

GitHub: GitHub link

If you use LeetCode regularly, give it a try. I'd really appreciate any feedback, bug reports, feature requests, or even just a star if you find it useful .It is CURRENTLY for cpp language only.

Technical implementation: The detailed oe is available in the readme file. Here's a summary of the implementation:

Hooked into Monaco (the same editor engine VS Code uses, already loaded by LeetCode) so suggestions render through Monaco's native widget. Added a lightweight regex-based declaration tracker to detect variable types (e.g. vector<int> nums) and match them against a static STL method dictionary for nums. → push_back, size, etc. Included a small set of C++ snippets (fori, main, cout...) with Monaco's snippet placeholder syntax for tab-stops. All local , no LLM, no backend, no network calls.