The most important thing in any project is consistency. If your entire project is build around JSR-330, is consistently using it, and it is not introducing unnecessary work to program using it (having to remember to use
Inject instead of
Autowired does not count as unnecessary work), as compared to e.g. direct Spring annotations, then one should stick to JSR-330 annotations. And forcing to mix them up just because I'm used to other type is a very weak argument.
Unless there's a collective effort (which is agreed upon) to globally change JSR-330 annotations to those of e.g. Spring, the JSR-330 should stay. But this applies vice versa: if a project is using Spring's annotations, it should keep using those.
Components such as CDI are components which are extremely unlikely to change over time. E.g. if your project is running on Spring, the chance you would migrate to a completely different framework (pretty much the only situation where you would benefit from using JST-330 instead of Spring's CDI annotations) is close to 0. And even if such migration to a completely different project happened, having to change the used CDI annotations would be the least of your troubles.
Additionally, if you're a sole developer building a project from scratch, it's your decision which approach you choose. And if a certain developer joins the projects after a substantial development period, the developer should acknowledge your decision and use the approach you've chosen.
On the other hand, if you're building a project from scratch and you're not the only developer working on it, the project is a team effort. The approach should be discussed among all participants and based on that the approach the most comfortable to the majority of developers should be chosen (unless a certain individual can present an extremely strong argument in order to use a different approach - and this usually does not happen).