That’s not quite right.

The tools are going to get better, and it’s going to lift everyone while doing so. But it will vary across task.

The bottom tier of engineers will have improvements to their code.

The top engineers will move faster. Top engineers will still be great at what they do.

—-

The same thing is happening in music. Everyone gets lifted but on different dimensions.

Unless there's a fundamental change in how the technology works, it'll never get to the point you're talking about. We're still waiting on our self-driving cars, remember.

Also, when it comes to music, who are the people in the rock and roll hall of fame? Those who can play the guitar real good? Or those who crafted songs that people love? AI will never be able to do the latter. But, AI can play power chords better than any session guitarist. That session guitarist is going to have to learn how to compete in another way than his guitar playing skill.

I don’t think it’s a craft thing, I think it’s a speed thing. Senior engineers are faster in their existing workflows.

I’ve found ai tools most valuable for:

1. Quick “how to do x in y” language

2. Large scale refactorings that are mostly mechanical.

This still takes a bit of guidance to get the right output (and breaking down the refactoring an into multiple steps). But it does speed things up when I would touch 40-some files. I still review all the code.

The evolution of the tailwind enthusiast is almost complete. Soon they’ll rejoin the old heads who never liked tailwind.

Use onshape, it’s so much nicer to use something browser based than desktop based. If you’re a student it’s free.

Watch 2-3 onshape tutorial videos and then just dive in trying to make parts for yourself.

If you’re new to 3d printing you’ll soon learn that what you design doesn’t always print right. Welcome to creating things in the real world. This is part of the learning experience (and why you need to learn by doing).

Onshape also has a bunch of public cad designs, so you can look at how other people made things to learn (sort of like reading source code to learn).

Modern react developers forget that if statements exist. When react was class based it was trivial to do:

  render() {
    if (this.dontNeedToRender) {
      return null
    }
  }

Now, because hooks can't be skipped, react developers jump through many hoops to use an if statement during rendering.

I might be missing your point, can you elaborate? If you want to write an if statement you just do it at the end of a component, after the hooks. It's a common pattern.

If you don’t use `async def` and you are using fastapi it’s easy to accidentally block the event loop.

> it’s easy to accidentally block the event loop.

Can you share a scenario where this would happen?

I have deployed multiple machine learning and data analytics-focused web services, and this has never happened to me.

Well, you can even block event loop in `async def` if you are not careful. When you are using `async def` you need to do all your IO (disk, network) operations asynchronously or your are blocking the event loop.

With a for loop? You probably don't know you are, or just aren't doing anything cpu intensive.

April fools?

> this is not something an engineer tasked with fixing an outage should be making the decision on

I don’t get this at all.

I’d much prefer a team of highly empowered and highly responsible engineers than impotent engineers who need hand holding in case they make a mistake.

Well, good thing that wasn’t what I suggested.

Engineers _should_ have leeway in how they resolve issues. As I read, though, you have a company policy which explicitly disallows the action you needed to take to fix the problem (if I misread, my apologies). Getting the stakeholders involved is the responsible thing to do when policies need to be broken.

Ideally, the way this kind of situation gets handled should be documented as part of a break-glass policy, so there’s no ambiguity. If that’s not the case, though, the business should get to decide, alongside the policy maker (e.g.: security), whether that policy should be broken as part of an emergency fix, and how to remediate the policy drift after the crisis.

If you’re all tight enough that you’re allowed to make these kinds of decisions in the heat of the moment, that’s great, but it should be agreed upon, and documented, beforehand.

Maybe.

There’s also folks that pair because they’re a crutch for one or two other engineers. The other engineers never improve or are let go, but softly slow down the team.

There’s also the folks that pair because their code doesn’t make sense on its own. Or they have some config files they’ve refused to check into the repo, etc.

Pairing makes them feel valuable.

> There’s... folks that pair because they’re a crutch for one or two other engineers [who] never improve.

I can imagine this happening if neither pair is all that good a communicator, and if the seniormost never employs a little Socratic dialog every now and then.

That’s not a good excuse

It's not even an excuse.