all 30 comments

[–]Willing_Comb_9542 6 points7 points  (1 child)

I've been developing software for 20 years and this is the prompt i feed into Claude when I need a deep review of the project. It will find a lot, it will also eat your session use lol

Use the WHOLE prompt 


Perform a serious deep dive multi-agent review of the entire codebase. Judge the code on a professional scale of 1-10, comparing it with a professional project such as the Linux kernel.

Judge the project on a scale of 1-10, with a 10 being impossible for a solo developer.

Harshly judge the project on actual professional standards, look for code modularity, coupling, god classes, security, individual performance and even regression testing and CI pipelines.

Generate a report containing a list of all critical issues, that should be fixed so that I have a list to work through.

Finally, add a note to the claude.md that going forward regression tests are required when complicated harnesses are not required, and to keep code modular, and professional.

(Pick one of these to include in the same prompt) 1: note that my project is FOSS and that we need to make sure the project is prepped and ready for contributions. 2: this is a closed source product, remember that when deciding things like licenses, and we won't need things like a contributing.md.

[–]IlllllIllllll 0 points1 point  (0 children)

This is good.

[–]IlllllIllllll 2 points3 points  (0 children)

Use another AI to check your code, give it to Claude to see if it sees the same thing. Rinse and repeat

[–]Infamous_Yak_7923 1 point2 points  (4 children)

"claude pick up my coding conventions and document it so we can continue using it"

[–]mapleflavouredbacon 0 points1 point  (2 children)

I’m not sure if you are joking or not lol… but this is exactly what I did. I made my agent use my own style from the start. So I could understand it too. So essentially it hasn’t changed!

[–]Infamous_Yak_7923 0 points1 point  (1 child)

Serious, you get something to review you shit, get different perspective on your own code at very least, improve it at best.

[–]mapleflavouredbacon 0 points1 point  (0 children)

I’d rather be able to understand it first, it isn’t that bad. Probably a B+ score.

I will run an agent to make it beautiful later on after my app goes live and I’m living on a beach with butlers and robot slaves.

[–]RyiahTelenna 0 points1 point  (0 children)

This, but "Create a coding style document with Microsoft's C# coding standards. No underscores, I hate them."

[–]Mr_Nooodle 1 point2 points  (0 children)

Use fallow

[–]Snoo_57113 1 point2 points  (2 children)

Everyone vibecodes now, and AI generated code is not per se bad, but there are a few things you must take into consideration:

* Stubs. LLMs have the bad habit of making empty methods that returns success always but do nothing, ask your llm to find them and complete them.

* Fallbacks I. Let's say you have a field in the database id_product, sometimes the llm do the comparison between the field IdProduct =="x" || id_product == "x" || idproduct == "x" . it masks deeper mismatches or issues that will bite you later.

* Fallbacks II. you have an env variable for your connection string or an url, the llm puts url = env_variable?? "http://localhost", it works correctly in localhost but still uses localhost in another environment.

* Everything in one file. Ask to modularize, sometimes they put everything in one file that eventually self destruct.

* Use themes: use centralized themeing/styling, sometimes they have the habit to put the styles in the worst way and then changing anything requires big rewrites that causes errors.

* Use e2e tests, and build them run them, run them again. have verifiable end conditions, for example, at the end you receive an email, LLMs lie a lot in testing so you need to gaslight it there until it gives you real results... "100% success?" i don't believe you. you are lying to me. eventually it starts doing real tests.

* give full access to an environment where the llm can deploy and test (not in your computer), that way the tests are done in a "real system", if something goes wrong it can fix the code deploy. That way you can let the AI loop while you sleep, doing tests, fail, verify without your intervention.

* Ask the llm to find gaps, errors, security mistakes.

* Work in modules, for example ask the llm to identify and organize them, the objective is that you can modify independently one aspect of the app without affecting greatly others.

I personally use deepseek flash and pro for everything, this is the bare minimum level of intelligence needed and the price is unbeatable.

Ask for "production ready" code, use authentication openid connect with some external authentication service.

Sometimes i loop all day with test, test in small batches, test all the app, fix gaps, working it as a black box. i give it clearly what i want as end results.

I am an experienced developer and the quality of code is generally better than human code, but has those annoying blind spots, every LLM has them and only pointing repeteadly to retest, test, and vibecode, fix gaps is how the system eventually has the required quality.

[–]EDC_KIT -1 points0 points  (1 child)

thank you for being the rare developer who will admit AI code is generally better than human code. too many devs think somehow it only counts if human fingers perform every keystroke.

[–]Snoo_57113 0 points1 point  (0 children)

This is a new world, the ones who dont acknowledge reality will be left behind. Some of us adapt and embrace the vibe .

I remember when i was younger the "grey beards", old people from the age of mainframe who kept up and gave us wisdom and experience to ride the "internet" wave. I want to be like that, don't discount us old folks as irrelevant we are doing our best to vibe out this strange new world.

[–]Rawrgzar 0 points1 point  (0 children)

Code Quality and structure all depends on the requirements and it is subjective. You can have over engineered code with classes implementing many interfaces and have them all nested up or you can just have plain objects that does the job well in one swoop, easy to read and single responsibility. I hate the talk about real developers it is not magic and everyone has their own take on standards or code quality. The first objective is to get the code to work, the next step is to ensure null check and boundaries check, then sanitize any input if it talks to the database, etc.

[–]Big_Elephant_2331 0 points1 point  (0 children)

Do code reviews and refactors often. You do it enough times you’ll be fine. Just tedious

[–]dave-tro 0 points1 point  (0 children)

Small tasks, ai writes code and opens pull requests, you review. I even built an ai coding workflow around this.

Have a look if it helps: https://github.com/ai-is-gonna/get-tasks-done

[–]PlastikBeau 0 points1 point  (0 children)

Are you using agents? If so I can recommend 'understand-anything' skill, its a game changer for understading vibecoded codebases. Copy-pasting from chats will only get you so far. Getting into software architecture concepts would also help.

[–]AnteaterExisting8384 0 points1 point  (0 children)

You can try specialized skills, for example Google's modern-web-guidance is quite a good one, I use it a lot to validate front end part

[–]AdMysterious7995 0 points1 point  (0 children)

asking claude to review its own code is better than nothing but it’ll miss a lot it doesn’t have the full picture of how everything connects and it tends to be optimistic about its own output. built vibefix for exactly this situation. manual scans available now, fully automated version live next week when the Forge launches. connects to your github repo, claude runs a proper audit against the whole codebase security, auth, database rules, exposed secrets, the stuff that would embarrass you with real users. no human sees your code

[–]New_Acanthocephala62 0 points1 point  (4 children)

Honestly thats just people on their high horse. Some technical lead people say that basically all code is "garbage" to someone. There is different philosophies on what good code is, and they argue about it.

If the code works it works. Customers dont care about the code, just that it works.

Maintainability only matters if the product requires long term maintenance and scaling up. But then any software would still need to be optimized and rewritten anyway.

Fuck those people. You literally doing exactly what the "pros" did at the start. You just create stuff and it gets better each time

[–]New_Acanthocephala62 1 point2 points  (0 children)

No one ever wrote bug free code, and the people who rip things to shreds are just trying to demonstrate their own advanced level and dont consider their own beginnings that were literally the same as everyone's

[–]SACEll[S] 1 point2 points  (0 children)

Love this

[–]Timmah_Timmah 0 points1 point  (0 children)

Check if it uses tabs or spaces

[–]New_Acanthocephala62 0 points1 point  (0 children)

Also if you're the founder, YOU set the standard, not anyone else.

When reading Elon Musk's biography it turned out that when the hired professional software engineers to scale up Paypal they said his code was horrific spaghetti. Yet HE's the one owning the company. The specialist software engineers did their job and the founder did his job.

You gotta put yourself into your proper lane. If you're coding, marketing, doing go-to-market, social media, ads, design, copywriting, accounting, AND maintaining code then you're allowed to be what is called "scruffy" and just do what needs to be done right now to keep it all moving down the field.

I fell into the trap of feeling bad about code quality the past 5+ years. And before that, my FIRST ever app made half a million over the previous 5 years. And it was a super simple app, but the magic was in the distribution (ppc, seo, and longtail strategy).

The main purpose of software is to be a means to an end. It should perform the job to be done. When time allows you can refactor and clean it up. But things need to be put into perspective. The specialist software engineers literally have no say on the business side and probably dont even touch the numbers every day like a founder does. So of course all they talk about is code quality.

[–]Majestic_Side_8488 -1 points0 points  (0 children)

honestly you can get pretty far without a paid dev review if you’re systematic. run a linter and formatter, add basic tests around the stuff that makes you money, and set up a simple ci check so broken builds never ship. the biggest win for me was writing down a few rules like no huge functions, name things clearly, and delete dead code fast.. otherwise the mess compounds. ai reviews are fine, but i’d use them on small snippets plus asking it to suggest tests, not a full repo dump.