[cgearhart]

This seems very related to a trend I’m seeing as my company goes all in on AI: everyone thinks that every problem is “a couple hours” with AI now, and they all want zero external dependencies because they can move faster alone. As a result, we’re now in an even worse “yet-another-…” age where everyone has built approximately the same (but somehow incompatible) versions of all the same beginner-level software, and (ironically) while they want no external dependencies they’re also pushing for org-level mandates to require everyone else to use their solution. Meanwhile, no one wants to do the slow/bottleneck part that cant easily be automated or scaled; they just throw an “agent” at it and call it done—but there’s nothing _there_. You can trust the agent on easy tasks and you can’t trust it on hard ones, but you can’t tell which ones are easy or hard. Improvements in foundation model tech move thresholds of the problem but can’t eliminate it.

Long story short, I think we’re in a phase where the organizational value function is lagging behind the tech. A “proof of concept” used to be correlated with “proof of work” and some amount of domain understanding, but I think now what we need is a focus on “proof of understanding” or else you’re probably just wasting tokens on a baby version of the problem. A decent proxy right now is that if you have zero external dependencies then your solution is probably a toy.

[Aurornis]

AI completely broke some of the signals management used as proxies for team competence. In the past, teams that moved quickly and had a proof of concept to show management were valued for the speed of their execution. Usually a team that could execute quickly had some competent developers who could also quickly execute on the challenges of the implementation when it scaled up to real world problems.

Now anyone with enough LLM tokens can move quickly and have a pretty proof of concept in front of management in days or maybe hours. There's a land grab to get things in front of management so you can stake your claim on something. The implementation details are assumed to be solvable by enough Claude sessions and ChatGPT prompts.

Where this falls apart is that the real difficult problems don't scale well with LLM brute force techniques. You need people who understand the problem and know how to drive the LLM agents around properly, as well as when to set them aside and go look at the code and data themselves.

The teams who try to brute force everything with LLM tokens can get a little farther every few months, but for complex problems I've seen enough variations of teams hitting a wall of complexity and tech debt with a team that doesn't know much about how their system works because they've just been asking agents to solve every problem as it comes up. With each iteration it takes a little longer for the agents to come to a solution and the system becomes a little more brittle. Even with our current mega-context-window LLMs you can reach a point where every other change to your big ball of code breaks something else, which requires another agent session to diagnose and fix, which might then break another thing down the line. The refactors to try to clean things up end up breaking even more. Having a zillion tests starts to backfire when the team can't tell which tests are testing valid results and which are baking in incorrect results.

Maybe there's an end game where agents get so good that none of this matters, but I think it's more likely that we're going to have to build up better intuitions about what good execution looks like. The old signals of moving fast are meaningly and potentially even negative now.

[Terr_]

> AI completely broke some of the signals management used as proxies for team competence.

This is very similar to how LLMs were already breaking signals in writing. It was (is?) an enormously important proxy (however imperfect) for a bunch of things like: "put effort into this" or "is smart" or "is interested and engaged" or "has an emotion" or "has carefully considered the idea."

Heck, even basic awareness of an issue/detail gets forged, mentioned in the text but never in the mind of the sender.

[nz]

In a way, LLMs have made it much more difficult to be believed. On the one hand, my inner paranoiac feels vindicated -- preparing for the worst case, over a lifetime, feels more prescient than it should. On the other hand, making decisions, specifically about how much faith to put into another unfamiliar human, becomes even less tractable.

The work can no longer speak for the human. A nightmare for the introvert.

The work, even before LLMs, struggled to speak for the introvert (and even the extrovert) -- a unique enough work usually results in puzzlement, a questioning of motives, and sometimes even overt ridicule.

Even for writing, it was a struggle. How many times did pieces of writing get ignored (or rapidly skimmed) because they were "TLDR"?

When I was very young (a teen), I wondered (after seeing the films The Matrix and Fight Club) to what degree other people were a dream-like hallucination (basically, those films made the concept of p-zombies accessible to a kid). That childish daydream, is now a reality. My inner paranoiac squeals with delight. Ah, the perversity. Even skill at deception itself can be faked, now. Even the beautiful can treated as if it were hideous.

I wonder if anyone ever made an episode of Star Trek, where one crew-member pranks another (possibly inebriated) crew-member, by having them wake up in a perfect holodeck reconstruction of their ship and crew. How long before they would notice? Weeks could go by, before a red alert dissolves the illusion.

It's after 3am, and I am not inebriated, but fuck I need to sleep. Sometimes I hope I drift into a coma, so that I can deal with things that are, on the one hand hallucinations, but on the other hand _not_ deceptions. There is a universe out there, where _their_ Matrix (film), is Vanilla Sky (amusingly, its inspiration was the film Abre los Ojos, released one year before The Matrix -- maybe in this universe, the Spanish Armada reached England).

Good night, you doomed, sad people.

[cgearhart]

This is exactly what I’m talking about. I’m seeing the same pattern. And the most useful proxy I’ve found so far for “we don’t understand the problem” is taking zero dependencies. It means that you haven’t bothered to understand what the library does and you think it can be replaced with something AI one-shots.

[tayo42]

> they’re also pushing for org-level mandates to require everyone else to use their solution.

That's how you get promotions when you don't do anything valuable lol ok done with the cynicism

[oblio]

Not cynicism, incentives. Everything is shaped by incentives. We make movies about heroes and martyrs because they're 0.001% of us.

[ehnto]

No disagreement here, the incentives for software have always sucked. People complain constantly about how everything is enshittefied, that's just corporate incentives manifested.

[jvanderbot]

Do this long enough and you really believe it's good, after all the years of being promoted for strong-arming people.

But hey, I do it. I prebake my own tools to work within the system, a new person joins, and I show them the tools as an example. Instead of learning what it does and why, they just learn how to use the tool (now via claude).

[petra]

Given the limits of LLM's regarding context, why is zero dependencies the goal ?

Shouldn't something like maximum reuse/abstraction, minimal written code, should be a better goal ?

Possible leading to more llm-scalable systems ?

[horsawlarway]

Two things.

1. Deps are an organizational hassle. They need review, get flagged as security and legal risks, and (mostly incorrectly imo) have been somewhat tarnished by the idea that deps are all just "leftpad" - simple things that are over abstracted. This is the "incorrect" argument that I don't really think should carry much weight, but often does win the discussion internally in organizations.

2. Deps can be misaligned with your precise needs, and you often end up "owning" them anyways the second you patch/fork/modify it in any way. This one is legit. It's a real thing that happens and is painful. Sometimes being honest that you should just be responsible for the thing in the first place is the right call. This one I buy as an argument, but it just doesn't apply to that many deps.

But the combination of the two makes larger organizations somewhat adverse to dependencies on average.

[cgearhart]

Zero dependencies should not be the goal. It’s just a modern retelling of “not invented here” syndrome. It’s an anti-pattern because now you own maintenance on something that is not your core problem. In every case I’ve seen so far, the problem is that the person running the LLM doesn’t understand what problems the library solves and so they erroneously think the dependency and their generated solution are equivalent.

[dominotw]

problem is that no one knows what to build and there are way too many ppl employed

[cgearhart]

I’m seeing kinda the opposite. At some point it becomes obvious what to build and there’s no friction to building it anymore. So you get a flood of low effort copies of the same thing and no one wants to depend on anyone else, and the old value function was that ownership matters. I think the new value function needs to be much more focused on outcomes—and ownership isn’t an outcome.

[beezlewax]

The result of this is huge wastage in terms of effort and tokens.

[resonious]

This is huge... At least from what I've seen, many companies (even if they don't know it) are largely sloppy R&D shops. Most people are on projects that are highly speculative and unlikely to generate revenue. But it often isn't framed that way. Everyone believes their project is the obvious way forward.