I feel like people expect Claude to just 1 shot a good story from their 2 sentence prompt.

But even a human needs to sit down and apply a structured or semi structured process over a non trivial amount of time/turns/iterations.

If you asked most people to write a short story out of nowhere with no context and 1hr. Most of them are gonna write some generic stuff.

I feel like it’s probably just complexity.

Different workloads benefit from specific types of optimisations.

Luck/randomness is directly against determinism. A way of making feel less mechanical and opening up the combinatorial state space? Essentially increasing the fun/interest without introducing high complexity necessarily? As well as narrow the skill range as you say, but not necessarily over longer time horizons.

Like you can do a 2d matrix of luck and complexity.

Tic tac toe - low randomness, low complexity

Chess - low randomness, high complexity

Poker - med randomness, high complexity

Roulette - high randomness, low complexity

And tbh I can’t really argue with that.

Its not so much about same file, as reducing distance to understanding, whether visually or by some sort of easily traceable path.

Like you would want to init a variable closer to its usage, Or that having a 100 wrapper functions is less understandable than inlining for a single statement, or global mutations are harder to trace then local, and that sometimes its easier to inline a single sql statement then split it out into a different file just because its 2 different languages.

Also, to be clear its possible to write CSS that exhibits less or more LoB. The file thing is more that I don't think HTML, CSS, JS "must" be written as separate files which is what the prevailing best practice used to be, justified as SoC. I just think splitting along the scope/behaviour lines rather than file type is more understandable.

With the rest I don't really strongly disagree. I think its just a question of complexity. For simple things its fine, but for complex apps with teams of people :shrug:

I don’t want/need cascade. I only care about components and building up from them. And I would rather have it be explicit over implicit and scoped/encapsulated.

Call it composition over cascade.

To be clear I think it’s possible to do this without tailwind. And tailwind has other out of the box features/opinions.

But it works well enough without too much friction.

In sql your code may be in a seperate file but your app code is still clearly calling the sql. The inlining vs not inlining is just abstraction. You could use a function, or a separate file or not, a different language or not.

But there is a clear single call chain at the points where that behaviour is being applied and a single definition.

With css that’s not necessarily true. There’s a bunch of different rules that may or may not apply.

There is a fair amount of people that disagree with the premise that it should be separated in that way (Including me).

I personally like this essay by the author of htmx on the topic

https://htmx.org/essays/locality-of-behaviour/

Also just better composition imo.

Practically I think this means components of scoped css, html, js.

People never seem to have the same complaint about mixing or separating app code and sql in the same way?

But another dumb idea I had was a set of random words inspired by Terry Davis godsay https://github.com/orhun/godsays

With a more appropriate wordlist appropriate. Call it muses.

Is it really surprising that llms don’t just one shot a unique story when they are all starting from roughly similar training data and state and a roughly 30 secs of processing time.

I had Gemini do some deep research for me around processes and frameworks to prompt ideation and creativity and they do exist. See SCAMPER and others.

Another interesting thing that comes up is using random decks of cards as prompts.

See Oblique Strategies, Deck of Lenses, the Story engine and similar.

I guess I still believe that even creativity is still fundamentally a type of search, as well as problem solving. Manipulating and or combining existing ideas in unexplored ways and breaking out of bias.

So I kinda want to experiment with these two approaches:

1. Longer running workflows that follow a framework and loop.

2. Some simple cli tools with these decks and a random draw to trigger interesting directions.

I think really just need to break llms out of their initial start state which is mostly the same for everyone.

And to run over longer horizons and so the higher level reasoning flows.

A mono repo doesn't necessarily mean large compile times, because it depends on the projects and their dependencies within that repo.

I think a mix of 2. and 3. is good for a small team or solo dev. Im throwing in a bit of homelab as well by adding some action runners and models on my desktop as well.

But cloudflare is great value for small teams. Not sure how it as at higher scale.

On the topic of env and config. It took me a while to get this write, and maybe overengineered.

But I invested a lot of time in trying to standardize env definitions, secrets manager, and per env config definition defined in my nx projects, and consumed by the commands or deployers. As well as pulumi for IaC.

I tried a couple of different approaches, but finally I just decided to use typescript as my config language. I use nx project.json but defined using typescript. And just define the env config as typescript functions to be injected to each command or deployment as a pure function of target env.

I’ve been thinking about setting up a non trivial project to use as a benchmark for any plugins and/or harness changes I make.

Having a prebuilt verification suite is great. You can use it to asses things like token usage, time, across different harnesses, models, plugins.