In my case, I am a very senior member of my team so 25-50% of each day is spent helping and/or teaching teammates. In situations like that, it is useful to be deeply familiar with the tools that your teammates are using so you can tell them exactly what to do.
For example, if I'm teaching a new hire to set up their vscode it is not very helpful to tell them "now you need to activate the python venv". It is much more helpful to be able to tell them "Now we're going to activate the python venv. To do that, open your command palette and search for 'select python interpreter'".
In my personal life, I still exclusively use emacs (which I have scripted to auto-detect venvs) but I put up with using vscode at work to be a greater utility to my team.
Idunno. I think you end up teaching them nothing and just doing it for them. I mentor plenty folks without learning more than basics of vscode/cursor, and the most important lesson for them is always how to figure out how to do stuff (which has never been easier than today).
Yeah, I kinda feel like when you're mentoring people, you should let them drive. If you're going to do it for them, you might as well just record a training video.
The point of the parent is that in an ideal situation, where everything works without flaw, theoretically it makes no difference which tools everyone uses. In real life, you having a homogeneous setup across a team makes the sysadmin's job a lot easier.
But sysadmins should be there to deploy stuff and make sure the infra does its job, not get bogged down handholding some dev that can't even compile a project.
I've worked at more than one place where administration and sys admins were the ones calling the shots. Certainly not the people actually producing stuff.
When I've been in that position, I've just trusted junior folks to figure out the tooling-specific way to do things like that, and it's worked out perfectly well. If anything, it leaves people happier and learning more.
And, instead, I can focus on the fuzzier, higher-level things that involve non-trivial tacit knowledge rather than things somebody can resolve with a Google search (or just ask Claude).
I can somewhat sympathize - I guess the debatable aspect is to what extent should you teach?
If someone knows no development tools, then yes, it is good if someone in the team knows Visual Studio Code and can guide them. In my previous job, another senior person knew it and helped out (VSCode was not mandated, and they were free to use some other tool).
I tend to focus on training people on the concepts (code navigation, debugging, version control, etc), and tell them that they're free to use whatever tool they like, but it's on them to learn how to use those tools to apply those concepts. I usually recommend VSCode and tell them there are plenty of videos/sites that explain them.
Then if I see them doing something very inefficiently, I do a quick Google search to see if the more efficient approach is supported in their tool and send them a link.
It's important to hire people who can learn on their own (with guidance on what to learn).
> For example, if I'm teaching a new hire to set up their vscode it is not very helpful to tell them "now you need to activate the python venv". It is much more helpful to be able to tell them "Now we're going to activate the python venv. To do that, open your command palette and search for 'select python interpreter'".
Inspired by a submission some years ago on HN, I came up with a different approach in my last job.
Everything the team did (including onboarding), had to be done via a just[1] recipe. No longer did we rely on outdated docs. just recipes, by definition, cannot be outdated because then we wouldn't be able to do our work.
For onboarding, we had recipes that automated as much of the configuration as possible. For things that required manual work, the recipe would print instructions, and prompt the user to press Enter when they had completed the task.
Sure, onboarding stuff can go stale as people don't onboard often, but we had a policy that if any senior team member had to help a newbie because the recipe was broken, then the senior member needed to fix the recipe and check it in.
I left the job, but I still talk to some of the folks there. They still love the recipes.
The only truth is running the tools from the shell. Plugins are great conveniences and productivity enhancers. But if your devs can’t use the command line to build your software, you need to stop everything and teach them that.
Now if you want to have a standard tool set that you provide documentation for and support, then if anyone uses a different tool they are on their own. That’s perfectly fine.
But if you don’t trust your developers enough to choose their own tools, how can you trust them to deliver important software for your company?
It's just less effort all round to have everybody using the same supported set of tools. I don't know if I've ever worked on a project that's gone so far as to actually mandate this, but a "should" (possibly in the RFC sense) is fair enough I think. Every project I've worked on has ended up with everybody eventually settling on using the same tools, because it's just overall less hassle that way.
(Regarding Emacs, I'm typically using it anyway for org-mode, so if I need to do some one-off edit or other - probably some keyboard macro thing - then I can just load the problem file into Emacs and save it back out again afterwards. I've only once been in the situation of neither being allowed to install it nor remotely connect to another machine to use it.)
For example, if I'm teaching a new hire to set up their vscode it is not very helpful to tell them "now you need to activate the python venv". It is much more helpful to be able to tell them "Now we're going to activate the python venv. To do that, open your command palette and search for 'select python interpreter'".
In my personal life, I still exclusively use emacs (which I have scripted to auto-detect venvs) but I put up with using vscode at work to be a greater utility to my team.