I didn't know tardigrades can be big enough to be seen with the naked eye. Apparently big enough to be seen but not big enough to be recognised without magnification.
> I've not understood the propensity for using yaml for CI pipelines and workflows in general. A decent programming language would be a big improvement.
Because it's clear to write and read. You don't want your CI/CD logic to end up being spaghetti because a super ninja engineer decided they can do crazy stuff just because they can. Same reason why it's a bad idea to create your infrastructure directly in a programming language (unless creating infrastructure is a core part of your software).
> Why not just build the workflows themselves as docker images? I guess running other docker images in the workflow would then become a problem.
That's how Drone CI handled it. GitLab kind of does the same, where you always start as a docker image, and thus if you have a custom one with an entrypoint, it does whatever you need it to.
IME on a Pulumi for IaC team, writing infra in a real language (TypeScript) is MILES better than- you can do conditions, have typed outputs, etc and not have it be a bastardized imperative YAML mess.
YAML is fine for data, but inevitably stuff like workflows end up tacking on imperative features to a declarative language.
> IME on a Pulumi for IaC team, writing infra in a real language (TypeScript) is MILES better than- you can do conditions, have typed outputs, etc and not have it be a bastardized imperative YAML mess.
You can have conditions and types without having the full flexibility allowing madness of a full language with HCL.
I enjoy it, but I also think my platform team has set it up in the best possible way. YMMV if it’s done differently- I am sometimes uncertain if I love pulumi, or how we do pulumi.
I really really want to use dagger, but I don’t think there’s organizational interest in it.
After having to deal with shell rc files causing chaos and unpredictability, I can appreciate your top level code fundamental not being random code but something that is parsable and not subject to the halting problem.
it's wild I can wiz through a ton of code for hours on end but seeing a yaml file for something like a CI pipeline actually makes my brain eject i dunno why. my brain has some sort of proverbial capacity limit with how many different configuration-file looking things I can tolerate in a day, and the prospect of becoming intimately familiar with what is effectively an auto integration presented to me as some sort of config makes me completely unjustifiably butthurt for no reason. have i not suffered enough needless and often times limiting abstractions already
I think you'd need to write a tool that goes through all revisions of a file and does a count, but if that's cached then it's doable. There's a few tools to view that by file though, including some Git commands, it's a valuable tool to determine which files are edited the most (see also the word "churn").
I'm surprised there's no mention of fzf. fzf has greatly improved my terminal experience and I tend to incorporate it into almost every script that has any interactivity. I think any terminal of the future could incorporate fuzzy finding much better.
And under water construction is expensive. And durable construction in a marine environment is challenging (and makes things more expensive).
That doesn't mean it's a bad idea but they are factors that add to the overall cost. 20$/kwh is very attractive of course. But that's also a number that e.g. CATL is chasing with sodium ion batteries. And they are going to be making those by the gwh/year from next month.
I feel like one small piece is missing to call it an agent? The ability to iterate in multiple steps until it feels like it's "done". What is the canonical way to do that? I suspect that implementing that in the wrong way could make it spiral.
When a tool call completes the result is sent back to the LLM to decide what to do next, that's where it can decide to go do other stuff before returning a final answer. Sometimes people use structured outputs or tool calls to explicitly have the LLM decide when it's done, or allow it to send intermediate messages for logging to the user. But the simple loop there lets the LLM do plenty of it has good tools.
So it returns a tool call for "continue" every time it wants to continue working? Do people implement this in different ways? It would be nice what method it has been trained on if any.
The model will quickly stop tool calling on its own; in fact, I've had more trouble getting GPT5 to tool call enough. The "real" loop is driven, at each iteration, by a prompt from the "user" (which might be human or might be human-mediated code that keeps supplying new prompts).
In my personal agent, I have a system prompt that tells the model to generate responses (after absorbing tool responses) with <1>...</1> <2>...</2> <3>...</3> delimited suggestions for next steps; my TUI presents those, parsed out of the output, as a selector, which is how I drive it.
Putting it inside docker is probably fine for most use cases but it's generally not considered to be a safe sandbox AFAIK. A docker container shares kernel with the host OS which widens the attack surface.
If you want your agent to pull untrusted code from the internet and go wild while you're doing other stuff it might not be a good choice.
Could you point to some resources which talk about how docker isn't considered a safe sandbox given the network and file system restrictions I mentioned?
I understand the sharing of kernel, while I might not be aware of all of the implications. I.e. if you have some local access or other sophisticated knowledge of the network/box docker is running on, then sure you could do some damage.
But I think the chances of a whitelisted llm endpoint returning some nefarious code which could compromise the system is actually zero. We're not talking about untrusted code from the internet. These models are pretty constrained.
reply