I love Julia for personal use but I couldn't imagine using it on a team. The developer experience is quite poor: it's very hard to figure out where all the overloads of your functions are coming from (the import system just dumps all exported symbols by default), error message and stack traces are pretty meh, and there is currently very little static analysis in IDEs.
I tend to use it the same way I'd use Jupyter notebooks. If something were mission critical I'd be wary of using Julia for it unless it's absolutely the best tool for the job.
As someone who works pretty much full time in and on Julia, I think the best answer is "it depends" (mainly on who you are and what production looks like for you). If production for you involves sticking code on a microcontroller, give us a few years. If it involves writing a giant web-server, you absolutely can, but we don't have a great reason for you to bother yet.
On the other hand, if production for you involves simulation, optimization or lots of data munging/analysis, you should very strongly consider it. JuMP is great for optimization (and being used in production to among other things optimize power grids). The DifferentialEquations ecosystem has by far the best solvers out there. The PDE side is very WIP, but for ODE's and DAEs Julia is significantly better than anything else out there. The DiffEq ecosystem is used in production possibly most notably by Pumas.ai which has been used in the development drugs and vaccines that are in use. The data analysis side of Julia has less in terms of stand out packages, but has the advantage that unlike low level languages, you get a lot of expressivity (better code reuse, lots less boilerplate, and interactivity), while compared to high level languages, you don't have to shove all your computation down into low level languages to get good performance. You can just write the code to solve your problem without caring about fitting it into a framework or reciting ancient runes to please the compilers of the past.
The bigger picture is that if you work in Python or Matlab and you have a program that runs in more than 15 minutes, you should strongly consider switching to Julia. Conversely, if you are working in C++ or Fortran and are annoyed about dealing with UB, needing a preprocessor because your language isn't powerful enough, or not having a good build/dependency management system, Julia is definitely worth looking at.
There are definitely some gripes I have with Julia's developer experience, but it also has some great parts. The REPL is great (before I came to Julia I hated REPLs but Julia's is really good). Package management is great (including for binary dependencies), and there are a lot of tools built in to let you interactively ask the compiler about all sorts of things.`@which` tells you where a function was defined, `@edit` lets you jump to some code and start messing with it, there are a bunch of `@code_<X>` macros that let you inspect each step of compilation all the way down to native code.
Lastly it depends on your team and what experience they have and what they are willing to learn. Julia has an interesting habit of taking scientists who only cared about their domains and turning them into compiler developers (or experts in solving numerical differential equations). Julia is in some ways fairly close to Python, Matlab, C++, and Lisp but in other ways is very different. If you come to Julia and try to pretend it's a normal object oriented language, you will be fighting it every step of the way, but if you are willing to try something new, it is really powerful.
Comment on your last point: 1 year of using Julia in at my day job taught me more about Python than Python did in 8 years. By learning Julia I came to understand why Python's performance is catastrophic.
