rikatee

That's my experience with co-pilots too:

- Generating tests

- Generating functions consistent with prevailing style of similar functionality in the existing codebase. The greater the consistency, the more helpful the AI is at generating.

- Telling me why my code is crap by adding a `# todo: ` above some code and seeing what the AI suggests should be changed :)

What other tasks do you see as good target for 5-10x boosts?

AI will not replace devs. Devs that use AI will replace devs that do not use AI.

The most effective devs will be those employing a fleet of AI agents, acting as the glue and guiding hand for what the agents should produce.

This helps us get to that future, so I think this has legs.

I use VS code. I will try this out.

However, Code Review Doctor is more of a "this MIGHT be a problem. have you considered..." rather than "it wrong"

FWIW my reaction was classic "expectations not meeting reality": weeks of work to do (what I thought) was a mutually beneficial helpful thing. I was naively not expecting non-positive responses and was ill prepared when you raised valid concerns I had not considered.

Again, I am working on that and sorry I was passive aggressive to you.

Bear in mind only 28% of codebases actually use built-in unittest package that this gotcha is affected by, so really it's 20 of 28% of 666 aka 10% ... but that claim would be hard to justify by folks that dig stats.

We do code review because we expect human error when the code was written by a human, but then we also expect not human error when the code is being read (reviewed) by a human? Any process that expects zero human error will always fail.

That's where linters add value: they allow devs to do what humans are good at (the creative complex and interesting stuff) while the bots do what bots are good at (the boring repetitive stuff)

https://github.com/keras-team/keras/issues/15854

resulting in

https://github.com/keras-team/keras/pull/15876

typo in the url (or in HN's markup) btw: it's https://codereview.doctor

the tests are only as good as the code they're written with, and as good as the code review process they were merged under.

test did not work but did not fail either, imagine being that dev maintaining the code that the test professes to cover. Imagine being the user relying on the feature that test was meant to check (if the feature under test actually broke).

It's static analysis SaaS that detects bugs and code smells and offers the fix right inside the GitHub PR, so no need to context switch - just click commit and continue with your day

This started life as a Django-specific toolbut I recently overhauled it to also support checking Python code in general hence changed the name from Django Doctor to CodeReview Doctor. So now it does both (and will do more languages and frameworks in future).

Feedback on landing page would be appreciated and of course give it a spin. it's free to public repos!

Eventually we will replace AST with a CST (Concrete Syntax Tree) because the tricks we used maintain new lines and comments indicate CST was actually needed.

Now it can be installed as a command line tool via `pip install django-doctor`.

So now instead of reviewing deltas in GitHub PRs it runs locally and analyses your entire codebase to suggests improvements.

A nifty trick is it uses the browser to allow you to pick and choose which suggestions to take and then adds `# django-doctor: skip foo` to lines you don't want changing.

Hopefully after 6 months, 1000 installations on github, and tens of thousands of builds in the cloud it shouldn't have too many bugs when running locally! Let me know!