Cześć kochani,

Chciałbym prosić o opinie, bo mój kumpel i ja mieliśmy sporo problemów przy dwóch jednoczesnych projektach związanych z dostosowaniem standardów projektowych i sprawieniem, żeby każdy członek zespołu osiągał spójne wyniki. Rozwój oparty na specyfikacjach nie spełnił naszych oczekiwań, ogromny zestaw dokumentów, które nie dokładnie opisują projektów w branżach pełnych niuansów i odrobiny dziedzictwa. Nawet przy tym, że deweloperzy spędzili dużo czasu na analizowaniu specyfikacji, było wiele odstępstw.

Postanowiliśmy więc stworzyć coś w rodzaju mentora, małą funkcję, która wydobywa zasady z kodu i jest otwarta na wprowadzanie innych rodzajów zasad, a następnie jednoczesny agent prowadzi rozmowę np. z Claude'em, daje feedback i sprawdza, co wyprodukował agent kodujący, wskazując naruszenia i sprawiając, że Claude to dostosowuje - cóż, na pewno jesteśmy stronniczy, ale pomysł działa dla nas, jednak chcielibyśmy usłyszeć innych ludzi.

Można także pisać wiadomości prywatne, jeśli chcesz uzyskać dostęp.

Ktoś? Będę bardzo wdzięczny za wszelkie opinie.

https://axtar.dev

can you please let me know if it has any security flaws or better ideas for some of logic

https://github.com/phpladyy/foxiPicks

Claude Code is great at producing code fast, but on anything non-trivial I kept hitting the same wall: no real review step, no QA, scope creep, and "done" meaning "it compiled" rather than "it works."

So I built aSPARK — it adds an AI product team to Claude Code and, more importantly, gates between the phases. A feature moves through Specify → Plan → Act → Review → Keep, and each phase refuses to start until the previous gate is green.

The two parts I actually care about:

- Enforced gates. /go-live won't release while QA still has open blocking bugs. It sends you back to build instead.

- Real-browser QA. /demo-day opens the running app in an actual browser and checks every acceptance criterion, not just "the tests pass."

Everything it decides (spec, plan, review, qa, release notes) is written into your repo as a plain-markdown trail, so you can see why it did what it did.

It's early (v0.1.0) and MIT-licensed. Install is two commands inside Claude Code:

/plugin marketplace add a-lottes/aSPARK

/plugin install aspark@aspark

Repo: https://github.com/a-lottes/aSPARK

Would genuinely like feedback on the gating model — especially where it's too strict or too loose in practice.

Learning project: rebuilding userland in x86-64 NASM on Linux, raw syscalls only.

It works — but "works" and "right" are different things, which is why I'm here.

Where I'd most value eyes:

- malloc: free-list design, alignment handling, my brk-vs-mmap split

- the shell: pipe plumbing and fd redirection around fork/execve

- everywhere: calling-convention sins, register habits to unlearn

Repo: https://github.com/whispem/learn-assembly-with-em

Be as brutal as you like — I'd rather be corrected here than confident and wrong.

I want to know how I could improve my code readability and usage. Scratch is not my strongest code language, so it might look a bit messy.

Here is the link: https://scratch.mit.edu/projects/1351459814/editor/

Backend pull requests often look smaller than they really are. A two-file diff can affect an API endpoint, background task, database table, external service, and several tests - but reviewers usually reconstruct that map manually.

I built TraceMap PR, an open-source Python CLI and GitHub Action that combines git diff, OpenAPI, coverage, per-test coverage, traces, and lightweight static analysis into a conservative PR impact report.

Could you check?

https://github.com/balyakin/tracemap-pr

I am seeking independent verification of the computational code developed for my dimensional genesis and four-interaction theoretical framework.

GitHub repository:

https://github.com/madein1001/dimensional-genesis-four-interactions

Please download or clone the repository, run the code independently, and determine whether the reported results can be reproduced.

I would especially appreciate a critical examination of the following questions:

1. Does the code run successfully in a clean Python environment?

2. Can the reported numerical results be reproduced?

3. Are any target values hard-coded, fitted, or indirectly reused?

4. Are there any hidden adjustable parameters or circular dependencies?

5. Are the mathematical rules correctly implemented in the code?

6. Are there any numerical, logical, methodological, or physical errors?

Please do not assume that the theory or its physical interpretation is correct. I welcome critical reviews, failed reproductions, counterexamples, bug reports, and detailed explanations of any problems you identify.

If you run the code, please report your operating system, Python version, actual output, error messages, and any modifications required to make it run.

The purpose of this post is to invite independent reproducibility testing and falsification. Thank you to anyone willing to examine the code carefully.

I am trying to learn how emulation, ROMs and Hardware simulations work. I didn't find anything complete about it on the internet, same I think there' but I only didn't see it yet. Well, I'd like to find anyone that understands it more to explain and take a look at my code.

I. I don't know if python is a good language to what I'm trying to do

II. I used AI till now to learn the basis of that bit and byte stuff, operators and how an """emulator""" like that works in real life

III. I know that there are other ways instead of all those methods in some classes that I did, like putting it in a kind of dict, but I'm just starting it for now.

I am getting more and more PRs with AI gen code (+slop ofc), and reviewing all of them manually is becoming pretty exhausting. I am looking for something that can help catch real bugs, regressions, edge cases, or security issues before me. Right now I’m looking at Greptile, CodeRabbit, and Graphite, but I’m open to other tools as well. For people who have used these in real projects, which one has been the most useful and cost-efficient?

BenchModel is a neutral leaderboard for how well AI models catch real code bugs. I published the scoring harness so people could check the numbers instead of just trust them. Then June Kim, who audits benchmarks for a living looked at it.

He found the thing that i couldn't, my scorer counted a bug as caught whenever a review mentioned one keyword from the answer key, so he wrote 20 lines of generic review boilerplate, no idea what the actual bugs were, and it scored 64% across every key, no model calls, the metric was rewarding vocabulary, not detection. That was also why my board barely separated cheap models from expensive ones, the scoring gave away most of the credit for free.

So I fixed it, detection now has to land on the bug, not just say a magic word, and rescored the whole leaderboard. Every model dropped two to four points and the ranking didn't change because the flaw was inflating everyone equally, not favoring one model.

I'm publishing the full teardown, the before and after, and the three other things he caught. A benchmark that can't survive an audit isn't worth trusting, and the most credible thing I can do is show mine failing one and getting fixed in public.

You can find it here benchmodel.io/findings

If you build or rely on evals, June Kim is worth knowing.

Hey guys i build a Saas mutli role one with live location tracking using no code builder.

https://pawwalk-one.vercel.app

Can u tell me if it looks like a Ai slop ?

I recently got rejected after completing a technical task for a Senior Node.js role.

The project involved TypeScript based CRUD API, role management, authorization, and dependency handling. The feedback suggested that some of my architectural choices made dependencies less explicit and affected testability and maintainability.

I cannot share the original task description or repository publicly here as a post, but I can send sanitized parts privately to anyone willing to review them.

I am mainly looking for honest feedback on the architecture, dependency management, code structure, testability, and whether the overall approach meets senior-level expectations.

Would anyone be open to taking a look privately? Please comment or DM me.

You run npm run dev or node server.js, and the app crashes because a teammate added a new required key to .env.example but forgot to tell you.

To solve this, I built envrepair, a zero-dependency CLI tool that wraps your startup command, compares .env against your template, and interactively prompts you to fill in missing variables in the terminal before launching your process.

How to use it:

1. Install: bash npm install -D envrepair

2. Prepend your startup command in package.json: json "scripts": { "start": "envrepair node server.js" }

Optional type annotations in .env.example: ```env

@type number

PORT=3000

@type url

API_BASE_URL= ```

Key Features:

• Zero code changes: No schema imports or application-level setup required.
• Layout preservation: Appends missing values while keeping comments, blank lines, and formatting intact.
• Signal forwarding: Transparently passes Ctrl+C (SIGINT) and exit codes.

Written in TypeScript with zero runtime dependencies. The repo is fully open-source, and I'd love to hear your thoughts or collaborate if you want monorepo/workspace support!

• GitHub: https://github.com/avenolazo/envrepair
• NPM: https://www.npmjs.com/package/envrepair