Agents and LLM-assisted coding currently work within the confines of already working hand-coded OSes, language frameworks, test harnesses and even CLI tooling. Pull one of those out, and agents become unhinged and they lose direction.

Two problems with it were that 1. often setup boilerplate overshadowed the actual essence of the documentation and 2. people abused them for e2e testing making for unreasonable reading (and slow testsuite runs).

GitHub Issues today seem bloated too, so perhaps your frame of reference has moved backwards while you weren't looking and suddenly Jira is fast?

Confluence is slow but pretty simple, standard wiki otherwise. Obviously, if I had a choice, it'd be nothing Atlassian.

git+markdown limits editing to developers only.

But I did hear good things about UK public health system as being one of the best working public healthcare systems, even if no system is perfect.

So when consistent UX is applied, both a professional and amateur alike can learn and trust that what they learned carries over.

The way system (and patients) survive is by relying on "connections": someone you know gets you to "jump the line" (it could be a nurse or a doctor or even a janitor at the same hospital you want to get a specialist to see you).

It ends up being similarly "fair" (iow, not), but at the very least, everybody will prioritize kids and young adults (though in children's hospitals, same pattern is present).

Private healthcare is reasonably accessible, but best experts are with public healthecare institutions (uni clinics) or when working externally, booked 3-6 months in advance.

You need to migrate from one login domain to another (rebranding, change of login providers...) and none of your customer credentials will carry over.

Your password might not be stored anywhere except in your head.

Your local storage gets compromised and your passkeys are there for the taking (password in your head isn't).

"Cloud" password managers who hold your passkey private key part is exactly like them having your password and are worse than websites having proper cryptographic hash of your password: they might not be e2e encrypting it (you were comparing with sites doing password hashing wrong too), so a breach exposes all your passkeys just the same.

My point is that there is no panacea. Passkeys are like SSH keys for the web. I still put a passphrase on my SSH keys. Do you?

I actually believe the opposite: exactly the fact that a reviewer had to develop a mental model independently is why code review is and remains valuable (and why people use different models when doing agentic reviews).

The biggest value of doing code reviews is in ensuring maintainability of the code (1. someone else can understand it, 2. it is readable and 3. can be evolved in the future) — everything else is downstream from that.

Problem is that we can't define precisely what is good enough or when software is "finished": I mean, we are trying to do that with human languages, so it should not be a surprise.

Yes, LLMs are now similarly aware of the average context a human would be aware of, but for anything specific to the situation a human has better chances of resolving the ambiguity.

However, a "standup" was invented to solve a particular problem: people, in isolation, do not always understand that they are stuck, and talking it through lets fellow humans identify their challenge.

The stand up part is mostly to encourage keeping it concise and short, so you only focus on what is actionable between all participants (waiting on a review, I am looking at this for the 3rd day and I think I am ok, anyone wants to brainstorm this...).

With agents, they get similarly stuck (completely or in a loop), and with each keeping a different context at any given moment, they might still be able to help each other.

Obviously, their memories are not like humans' (there is no "I touched that two months ago, let's discuss after"), but there might be a different sweet spot where having them sync regularly (every 1M tokens instead of daily?) might be useful as they are also parallelizing work.

They have other issues as well, but among other things, I'd classify them as somewhat charitable too.

Would you say you could be serious in stating this?

Did they all not get that developers need full control of their tools?

Or they are hoping to turn this into a brave new (old) world where you are at the (bigger) mercy of proprietary vendors?

Obviously, the system should provide ample time by warning in advance of reaching it (and could even offer suggestion to keep it at N times your peak from M months ago).

If as a business you set your spending limits so tight that you frequently run into them and it's not some unusual activity, the problem is not that spending limits are available :)

It is mostly about protecting from the unknown, likely unbounded attack on your infrastructure, where your spend might grow 100x: even if you can take $100k, you might not be able to take $10M in a month.

This type of warning should give you enough time to investigate if the warning is real and adjust the spending limits.

But then again, even if you hit them and your services get paused, you'd be increasing the spending limits and restoring services after you are back at work and notice they are down, so it mostly comes down to your incident response times.

Does not fully stop the pressure ("we'll find another licensed engineer to retain"), but at least ensures a somewhat level playing field between expertise and investors.

It's not about the word itself, it is about what it represents and the risk profile if it's true (nowhere to run to).