r/codereview

We vibe code. We speak things into existence. But sometimes the robot gets a little too excited and gives us a 500-line monster file, a function that does literally everything, and ten // TODO: implement this comments sprinkled around like confetti.

Got tired of negotiating. So I built a tiny ESLint plugin called eslint-plugin-ai-guardrails that just tells the AI assistant to chill out. Four rules: max file lines (300), max function lines (50), no orphan TODOs without a deadline, and no comments that just repeat the code like // set x to 5 right above const x = 5.

Now my robot and I have a better relationship. It still generates code, but the guardrails keep things tidy. One command setup: npx eslint-plugin-ai-guardrails init

npm: npmjs.com/package/eslint-plugin-ai-guardrails
GitHub: github.com/isaacnewton123/eslint-plugin-ai-guardrails

Anyone else build tools just to keep the AI in check? Share your "negotiation" stories!

Hey everyone. I recently picked C back up after years away from it, and to get back into the mindset I implemented SHA-256 from scratch.

One deliberate choice: no pre-generated lookup tables. Both the K constants and the initial H values are derived at runtime from the first 64 primes, following the spec. The point was to understand where the constants come from, not just copy them in.

I also added a small interactive debug shell to inspect the internal state round by round.

Not production-ready, clearly. What I'm really after is feedback on code quality: structure, clarity, and anything that could be done better. I'm getting back into C and want to improve.

Note: I'm using camelCase rather than snake_case, also for function-like macros: just a personal style preference, happy to hear thoughts on that too.

Also: if you want to compile it, be aware that I'm using a GCC built-in function, portability is on my list.

Repo: https://git.dksengine.com/dks/SHA-256

hi everyone.

i'm new in the field of releasing fully open source projects to the world,

so shooting my shot.

i've been working on something very cool in the past few weeks,

something I had in mind for long time, but just couldn't get to solve it,

and after some long nights researching & reading about the most deep shallow parts of git, I think i managed to solve it!

the core issue - git is NOT built for ai-driven development.

- undoing work is almost impossible (/rewind is working like shit imo),

- knowing which session / context caused which change - the "why did you change it?" works only if u are in the same session (and not after a f**king /compact)

- viewing the file tree in correlation to the actual context & prompts

- forking/ branching - splitting conversation context to new conversation (branching basically).

- and much more, but you see the idea

at the moment i keep releasing new features & fixes,

I released an alpha version, still requires some work...

and i'm looking for some feedbacks and possibly some contribution.

https://github.com/regent-vcs

would love to hear what the community think

notes:

- at the moment i'm only supporting claude code

- there are 2 repositories - one for the actual cli, another for vs code extension

Hi guys i am currently baffling between TRAE IDE Pro plan versus the Opencode Go coding plan. What i would like to know is the quota limits between the 2 plans, how far/long can i stretch them?

And i would love to some thoughts about Chutes.ai Pro plan, Warp pro plan and Augment code Pro plan if possible

Hey, I'm a beginner and I was tired of calorie trackers wanting my email, a subscription, and cloud access. So I built one that lives entirely in a single HTML file. No dependencies, no backend, data stays in local storage. Would love any feedback!

I have attached the link for the GitHub Repository, but if you don't know how to use it you can always dm me and I'll send the html file.

Demo video

Thank you for your time.

​

I Built a code governance scanner that doesn't just fix your code it certifies it. Every repair gets a cryptographic audit trail, proof of rescan, and a signed artifact. This is what a governed repair looks like."

Didnt think it would work at first same input same output well it worked way better than i expected

A Gold snippet is a governed RC4 repair artifact.

It contains the repaired code, the original identity, the structural anchor, hashes, repair recipe, proof result, rescan result, Scan ID, Repair ID, and attestation.

The code is only one part.

The governance + proof wrapper is what makes it Gold.Where RC4 comes in:

RC4 is the repair class / standard.

It means the snippet did not just get edited. It went through the governed remediation contract:

Find it → Fix it → Prove it → Record it

\> Gold snippet = governed RC4 repair artifact

Inside it:

GOLD SNIPPET

├─ repaired code

├─ before/original code identity

├─ governed lane: Gold

├─ RC4 repair class

├─ structural anchor

├─ file / excerpt / subtree hashes

├─ rule / detector / template identity

├─ deterministic repair recipe

├─ governance decision trail

├─ proof result

├─ rescan result

├─ Scan ID

├─ Repair ID

└─ attestation / certificate

A Gold snippet is not just repaired code.

It is a governed RC4 repair artifact: repaired code with structural identity, deterministic recipe, proof, rescan result, and attestation attached.

The framed certificate in the photos is my first ever successful governed repair — Pattern #001. I printed it for $0.70 and framed it for $3. It's signed with HMAC-SHA256 and I'll never be able to generate that exact artifact again.

The gold nodes in the dependency graph are files with verified, governed repairs attached. The fan view shows a single file's proof path every connection is traceable.

When I ship, your codebase won't just be fixed. It'll be certifiable.

X185GC Framework Only While in Beta Compliance certification coming post-launch.

Oh Every repair saves a governed metadata snippet. Opt in and that snippet feeds the next repair. No AI API costs. No cloud fees. The repair library grows from the community. The more repairs, the smarter it gets.

No AI in the repair pipeline. Zero contamination. Deterministic.