It's not that difficult to get a base level game up and running; ESPECIALLY with modern tooling.
1,387 karma · joined July 15, 2023
It's not that difficult to get a base level game up and running; ESPECIALLY with modern tooling.
And that's the part AI is not going to be able to help you with.
You're contradicting yourself. I promise it wouldn't take you months, unless you're just a really bad developer.
>This assumes that I'm not Democrat.
No it doesn't. It's not even about you? English seems like your first language so I can't help but feel there's something else going on here.
You're just being a troll at this point. Goodbye.
Where? No one has stated anything. Everything has been a _direct_ response to your own words.
Those were your words, not mine.
Whether you are a Democrat or any other party member is kind of irrelevant; although it certainly is amusing.
Economists by and large tend to be academically and principally in support of many progressive positions so I'm not sure your statement can be read any other way than "I don't like perspectives that disagree with my primed and preconceived beliefs"
Which is an exceedingly common phenomena in a post-truth world. But it's quite obvious; just want to point that out to you.
For decades, professional American economists vote for the democratic party at a rate greatly exceeding the general population and profess support for ideological progressive positions that is also at a notable rate higher than the general population.
You know, there's also something to say about how people invoke the term "economics" in their own personal posts as some sort of grandstanding dog-whistle but we'd be here for hours.
Any day now...
We don't have a good scientific or philosophical handle on what it actually means to "think" (let alone consciousness).
Humanity has so far been really bad at even using relative heuristics based on our own experiences to recognize, classify, and reason about entities that "think."
So it's really amusing when authors just arbitrarily side-step this whole issue and describe these systems as categorically not being real but imitating the real thing... all the while not realizing such characterizations apply to humanity as well.
They're not just consumers, they're actual engineers. People who simp for companies like MS are just acolytes in developer's clothing.
If you only know one stack from one company, then you built your career on esoteric, arbitrary knowledge. Not on engineering things.
What could be the difference? Oh dear, I just can't think of anything.
Why does this matter? How does that invalidate anything? Are global companies only accountable for their actions so long as they maintain the same CEO?
>but don't be hateful!
Won't someone please think of the poor global technology conglomerate!
It's so sad that this is all it takes for some of you lol. A collection of public relations code bases.
That is what the original article is describing, and what the comments misunderstood or purposefully over-simplified, and extends it to being able to trace these issues across a large amount of calls/invocations at scale.
>MCP has none of this richness. No machine-readable contracts beyond basic JSON schemas means you can’t generate type-safe clients or prove to auditors that AI interactions follow specified contracts.
>MCP ignores this completely. Each language implements MCP independently, guaranteeing inconsistencies. Python’s JSON encoder handles Unicode differently than JavaScript’s JSON encoder. Float representation varies. Error propagation is ad hoc. When frontend JavaScript and backend Python interpret MCP messages differently, you get integration nightmares. Third-party tools using different MCP libraries exhibit subtle incompatibilities only under edge cases. Language-specific bugs require expertise in each implementation, rather than knowledge of the protocol.
>Tool invocations can’t be safely retried or load-balanced without understanding their side effects. You can’t horizontally scale MCP servers without complex session affinity. Every request hits the backend even for identical, repeated queries.
Somehow comments confused a server <-> client interaction which has been a non-issue for decades with making the rest of the "call stack" dependable. What leads to that level of confusion, I can only guess it's inexperience and religious zealotry.
It's also worth noting that certain commenters saying I "should" (I'm using this word on purpose) read the spec is also pretty laughable, considering how vague the "protocol" itself is.
>Clients SHOULD validate structured results against this schema.
Have fun with that one. MCP could have at least copied the XML/SOAP process around this and we'd be better off.
Which again, leads back to the articles ultimate premise. MCP does a lot of talking and not a lot of walking, it's pointless at best and is going to lead to A LOT of integration headaches.
This really is not that hard to understand. The LLM must be "bootstrapped" with tool definitions and it must retain stable enough context to continue to call those tools into the future.
This will fail at some point, with any model. It will pretend to do a tool call, it will simply not do the tool call, or it will attempt to call a tool that does not exist, or any of the above or anything else not listed here. It is a statistical certainty.
I don't know why people are pretending MCP does something to fix this, or that MCP is special in anyway. It won't, and it's not.
Make sure you have a good understanding of the overall model: https://hackteam.io/blog/your-llm-does-not-care-about-mcp/
Then take a look at research like this: https://www.archgw.com/blogs/detecting-hallucinations-in-llm...
It's amusing to watch people refer to MCP as a set of tools, or a framework, or an SDK you can invoke, or something or other across a wide range of forums.It's just a standard. A convention. Calling it a protocol is a stretch as well. But there's no meat to it, really.
If you just used Rest API's, you'd need to create little "tools" (say, another executable) locally that the LLM can invoke that can call those API's. MCP standardizes what those tools should act like and their overall lifecycle model.
The references to it being like USB are also quite frankly absurd and delusional.
But that's the caliber of developer we're dealing with today.
You are REALLY, REALLY misunderstanding how this works. Like severely.
You think MCP is being used for some other purpose despite the one it was explicitly designed for... which is just weird and silly.
>Confusing these two issues can only happen if you think the model does something with each response that controls whether or not the toolchain validates it
No, you're still just arguing against something no one is arguing for the sake of pretending like MCP is doing something it literally cannot do or fundamentally fix about how LLM's operate.
I promise you if you read this a month from now with a fresh pair of eyes you will see your mistake.
No they're literally just skipping an entire step into how LLM's actually "use" MCP.
MCP is just a standard, largely for humans. LLM's do not give a singular fuck about it. Some might be fine tuned for it to decrease erroneous output, but at the end of the day it's just system prompts.
And respectfully, your example misunderstands what is going on:
>* The Claude API, which is more structured than "text in, text out".
>* The Claude LLM behind the API, which generates a response to a given prompt
No. That's not what "this" is. LLM's use MCP to discover tools they can call, aka function/tool calling. MCP is just an agreed upon format, it doesn't do anything magical; it's just a way of aligning the structure across companies, teams, and people.
There is not an "LLM behind the API", while a specific tool might implement its overall feature set using LLM's, that's totally irrelevant to what's being discussed and the principle point of contention.
Which is this: an LLM interacting with other tools via MCP still needs system prompts or fine tuning to do so. Both of those things are not predictable or deterministic. They will fail at some point in the future. That is indisputable. It is a matter of statistical certainty.
It's not up for debate. And an agreed upon standard between humans that ultimately just acts as convention is not going to change that.
It is GRAVELY concerning that so many people are trying to use technical jargon of which they clearly are ill-equipped to do so. The magic rules all.
Which is completely fucking irrelevant to what everyone else is discussing.
That was based on decades of experience in .NET and Windows. Not the article ;).
>The LLM "chooses" to use a tool
Take a minute to just repeat this a few times.
It doesn't. I don't know why the other commenters are pretending this step does not happen.
There is a prompt that basically tells the LLM to use the generated manifest/configuration files. The LLM still has to not hallucinate in order to properly call the tools with JRPC and properly follow MCP protocol. It then also has to make sense of the structured prompts that define the tools in the MCP manifest/configuration file.
It's system prompts all the way down. Here's a good read of some the underlying/supporting concepts: https://huggingface.co/docs/hugs/en/guides/function-calling
Why this fact is seemingly being lost in this thread, I have no idea, but I don't have anything nice to say about it so I won't :). Other than we're all clearly quite screwed, of course.
MCP is to make things standard for humans, with expected formats. The LLM's really couldn't give a shit and don't have anything super special about how the interact with MCP configuration files or the protocol (other than some additional fine-tuning, again, to make it less likely to get the wrong output).
The LLM has everything to do with that. The LLM is literally choosing to do that. I don't know why this point keeps getting missed or side-stepped.
It WILL, at some point in the future and given enough executions, as a matter of statistical certainty, simply not do that above, or pretend to do the above, or do something totally different at some point in the future.