None of the things I can think of have anything to do with avoiding problems.

To some degree, having 5+ agents working on different projects is similar to leading a team of 5+ people. The skills translate well.

The senior is also able to understand what the agents do, review and challenge it. Juniors often can't.

And finally, the senior has a deeper understanding of what the business and problem domain are, and can therefore guide the AI more effectively towards building the right thing.

To avoid context-switching from the command-line, many essential UIs were made text-only. Another route would have been to integrate the command-line within graphical applications, but few did it -- the main example that comes to mind is Jupyter.

OrbStack isn't open-source though and I can't justify buying a license for every single person in my company just for something functionally equivalent but performing better.

These kinds of things should just be provided by Apple as a first-class thing.

I've seen some produce stuff without really understanding it, barely review anything, and pretty much suffer from imposter syndrome.

Takes zero effort other than CPU cycles.

Doing plain C structs doesn't prevent any of this.

In practice you probably want to have both, and choose what's most practical based on the message.

For topics which are sending the state of something, a gap naturally self-recovers so long as you keep sending the state even if it doesn't change.

For message buses that need to be incremental, you need to have a separate snapshot system to recover state. That's usually pretty rare outside of things like order books (I work in low-latency trading).

For requests/response, I find it's better to tell the requester their request was not received rather than transparently re-send it, since by the time you re-send it it might be stale already. So what I do at the protocol level is just have ack logic, but no retransmit. Also it's datagram-oriented rather than byte-oriented, so overall much nicer guarantees than TCP (so long as all your messages fit in one UDP payload).

Plain C structs that fit in a UDP datagram that you can reinterpret_cast from is still best. You can still provide schemas and UUIDs for that, and dynamically transcode to JSON or whatever.

And yet it will insist on only giving you binaries that match exactly. Thankfully there are experimental extensions that allow it to automatically fall back.

That's what you'd do if manually scheduling. Ideally the dynamic scheduler would do that on its own.

The expectation is that the kernel should somehow detect applications that are spinning, and avoid preempting them early.

Going to A&E and waiting there also means you're losing 4 to 6 hours.

111 you just get some robot asking you a never-ending list of inane questions before someone tells you to either self-care at home or go to A&E.

A pharmacist should be able to administer the supplies they sell, particularly wound dressing and care. It's a requirement in some other European countries like France (where pharmacists are doctors), but in the UK the reality is that most are unable to do so.