taberiand

One way is mentioned in the article, expanding and improving MCP integrations - give the models the tools to work more effectively within their limitations on problems in the context of the full system.

Based on the list, LLMs are at a "very smart junior programmer" level of coding - though with a much broader knowledge base than you'd expect from even a senior. They lack bigger-picture thinking, and default to doing what is asked of them instead of what needs to be done.

I expect the models will continue improving though, I feel like most of it comes down to the ephemeral nature of their context window / the ability to recall and attach relevant information to the working context when prompted.

You keep saying using multiple state files is a hack and a workaround. It's not, it's how you're supposed to use the tool, and it's a good way to think about and manage infrastructure.

Applying changes in a structured, staged approach via that separation is a great way to avoid issues that will be obfuscated when managing infrastructure in other ways.

The point is terraform can do it, and it does it well. Just because you don't want to use Terraform properly doesn't mean it's bad at what it does.

Using "a real programming language" to do the infra still has to solve the same issues faced by terraform. Using a programming language to define infra doesn't solve the auto scaling DNS issue, for example, you'll be using lambdas to create the dns either way. It also doesn't inherently solve coordination of the resource deployment, you still need to organise your code into modules and ensure the order of execution.

If you think Terraform is the problem here you're blaming the tool for a failure of process and understanding

You can't do it if you have the instances created with auto-scaling groups of course. But nobody would think you could, that's runtime not infra.

With Terraform you are supposed to have multiple coupled state files, with a tree structure of references, so that eg the state file containing the DNS can reference the previously applied state file that created the instances

You are supposed to run terraform apply in a sequence that respects the dependency graph. Terragrunt makes this trivial.

You don't need to write all the tf upfront for existing resources.

Use `import` resources in a .tf file (I like to just call it imports.tf) and run `terraform plan -generate-config-out=imported.tf`

That will dump the tf resources - often requires a little adjustment to the generated script, but it's a huge time saver

Except it's not, because their example is trivially easy and common in Terraform.

There is no Kompromat that could ruin Trump at this point

They are doing it because they want to.

Yeah, and the emperor has no clothes

We'll never build true AI, just reach some point where we prove humans aren't really all that intelligent either

Economists claim on average we eat a burger each; voters vote in politicians who want to "cut the wasteful burger budget and lower taxes on steaks"

I'd consider using a small magnet taped to the drill. Though I usually just use my pocket

I think you think the llm is a magic box with an intelligent being inside that can magically do whatever you want it to, somehow. It is software. It has capabilities and limitations. Learn them, and use it appropriately. Or don't, you don't have to use it. But don't expect it to just do whatever you think it should do.

The llm is able to see the gorilla when shown the image in the same way you would show a human an image.

Imagine if you gave someone the raw data and told them to write code to graph the output but on to a screen they couldn't see. They would not be able to tell you it's a gorilla until you turn the monitor around and show them.

Humans are still better at seeing the image, sure (for now), but the llm is a tool with certain features and abilities. You can't make up a scenario that is misusing the tool and then pretend that it doesn't work - especially when it seems you want it to use it without applying your own brain power to the process

And to be clear, I'm open to criticism of llms and exploration of their limitations - but I'm tired of hearing complaints that amount to PEBKAC.

That's a feature that would need to be implemented. There's no reason to think it could look at the image of the plot it generated automatically, but feeding it the image it generated back to it is no different to if it did view it automatically

I don't know why you would expect it to see a gorilla without an image to look at. Humans can't.

To be fair, if someone gave me a bunch of raw data points and not the png I wouldn't see the monkey either

I tried it on gpt4o with an upload of the image and "What do you see?" as prompt and it said "monkey". So ymmv, these tools can't be evaluated with just a bunch of gotcha prompts and ignorance of how to use them effectively

I think you asked a yes bot to say yes to you. Did you set the context for the llm to ask it to be thorough and identify any unusual steps, ensure its feedback was critical and comprehensive etc etc? These tools don't work if you hold them wrong

Eg, from uploading the gorilla scatterplot to gpt4o and asking "What do you see?"

"The image is a scatter plot of "Steps vs BMI by Gender," where data points are color-coded:

Blue (x) for males

Red (x) for females

The data points are arranged in a way that forms an ASCII-art-style image of a "smirking monkey" with one hand raised. This suggests that the data may have been intentionally structured or manipulated to create this pattern.

Would you like me to analyze the raw data from the uploaded file? "

I have custom instructions that would influence its approach. And it does look more like a monkey than a gorilla to me

I was very happy with how Patriot ended though - it's probably heavily influenced by where my head was at when I watched it but it left me deeply affected for days, and it's the only show to ever do that.

Maybe in how it's taught, but in practice deep inheritance and mutable state is easily avoided and best practice is more for a more procedural style

Each new C# release seems to borrow yet another F# feature, to its benefit. I prefer F# too, but at least I can convince the team to use C# - F# seems to be a bit too intimidating (in its awesomeness, I assume) for most devs to learn.

The C# tooling is very refactor-friendly. I commonly just build the class then pull out the interface later.

C# does want to have interfaces though, and gravitates to the common interfaces - core services - composition/DI root architecture, with lots of projects in the solution to provide separation of concerns. I think it works very well generally for business software at least, but I hear plenty of grumbling about 'complexity' so it's not for everyone.

I like go, and I use it to get stuff done. I'd be able to get stuff even more done with sum types and pattern matching and better generics and iterator tools and it's a shame Go doesn't have these things.

The solution is to educate people on how to use these tools, and identify propaganda, and use critical thinking, and generally be more aware and proactive. I'm under no illusions why this isn't the solution taken by the government.

That still fundamentally comes down to a bad use of the tool though.

Why are people relying on these LLMs for historical facts?

I don't care if the tool is censored if it produces useful code. I'll use other, actually reliable, sources for information on historical events.

Good point. Nationalise essential services

I advocate this with every newbie to git - find a UI that works for you and use it over the cli. Barely anyone listens though, and then they struggle with the cli and make a mess of their branches and fall out of date with main and are scared of rebasing and have many other issues that are solvable with a drag and drop or similar in a UI. I figure it's a sort of masochism.

The whole post in tongue in cheek, it just means "features the game you're making doesn't need (like modern graphics with advanced shaders and super high resolution requiring the latest graphics cards)".

If you're making a game that needs those features, obviously you'll need to bloat up. If you're not, maybe this SDK will be enough and be fast and small as well.