Thankfully, throughout contemporary history, people have attempted to tear it down. Philosophers have attacked the implied “I” within cogito, and others have attacked the idea that private knowledge (as the statement is about oneself) can ground public knowledge, at all. Descartes has one “trump card” that has repeatedly been deployed to counter these claims though, which is that the act of doubting the act of thought implies that you are indeed thinking.

I hated the simplicity of this rebuttal, and have always sought to kill it.

Here’s how I did it. In three steps:

1. I show that cognition can regress infinitely, leaving no base case for the Cogito to stand on.

2. I show that this makes the Cogito vacuously true, logically valid but epistemically empty.

3. I show that an LLM proves this setup is not just hypothetical but physically instantiable, and that the “proof” cannot distinguish between a mind and a while loop.

Descartes himself anticipated that others would attempt to use the crux of my argument here against him. Namely an all-powerful demon as he called it, that would fabricate your entire reality. And his response was again as simple as earlier. Even if the demon faked everything, he must exist, in order to be deceived. Being deceived is thinking, which was again the exact same trump card as before.

But what if your entire thought chain was fake. Your very experience of “cognition”, a falsehood, created by some all-powerful jester that tricks you into thinking. It is tricking you into thinking, with your recognition of that also being fabricated. Every layer of cognition you reach for is yet again another layer of the trick. It recurses forever.

More concretely:

When you are aware of a jester that is tricking you into thinking, and smugly sit down thinking that “you have doubted your thought and thus must be thinking”, there is yet another jester that has tricked you into thinking that a jester has tricked you into thinking. This loop can be unrolled infinitely.

The conclusion from this hypothetical infinite jester setup is that there is no cognition at any point. Descartes’ classical rebuttal cannot apply here since it assumes that there is some base case from which real cognition stems. It’s jesters all the way down, and Descartes has no answer for that.

Now, many of you will immediately object:

“But Haashim, you are clearly thinking about the jester. You wrote this article. You are doing cognition right now. Descartes wins.”

That’s the trump card again. And it does feel powerful. But hold that thought, because the next section explains exactly why it doesn’t work. Something can be the site of an apparent trick without that something being a thinking thing. I need to make that concrete before the objection lands. Stay with me.

Let’s look at an LLM-Based Agent.

function run_agent(prompt)
    context = "" + prompt
    while true do
        context += llm(context)
    end
end

Shitty pseudocode, I know, but you get the gist. It’s a loop that calls an LLM, with an increasing “history”. You’ve definitely used them. If you’re on my page, reading my blog, making it this far, you’ve probably even written your own. Now look at what this agent does. It reasons. It doubts. It argues. It responds to nuance. Heck, it can even defend and steel-man Descartes better than most philosophy students can.

Upon closer analysis of the loop? Oh... wait. There is no “I” there. Instead, a probabilistic machine that is being tricked into thinking. Haven’t we been here before?

Indeed we have. This is the physical instantiation of my infinite jester. A concrete system, running on a computer someplace, that performs every behaviour that Descartes’ assertion associates with genuine cognition. And I hasten to say that it is plausibly not thinking at all.

And this is crucial: the LLM is something. It exists. It is a physical substrate. A causal process is happening on a server rack somewhere. So the objection “for there to be a trick, something must be tricked” is answered. Yes. Something exists. The server rack exists. But existing is not thinking. A substrate can be the site where the trick happens without that substrate doing cognition. The LLM demonstrates that this is not just coherent, but actual. It is a real thing, being “deceived” in a functional sense, producing Cogito-like claims, and plausibly not thinking at all.

So Descartes cannot leap from “something is being deceived” to “something is thinking“ to “I exist as a thinking thing“. The gap between “a process is occurring” and “a mind is thinking” is exactly the gap the LLM exposes.

Descartes would respond quickly:

“I never claimed it works from the outside. It is a first-person proof. I know I am thinking because I am the one doing it. Your LLM is irrelevant, because I am not claiming it thinks. I am claiming that I think.”

But that is exactly the problem. The agent would make the identical claim. It thinks, therefore it is. It does say this. I’ve asked it. And neither you, nor Descartes, nor anyone else can determine whether that claim is genuine, or the output of a while loop.

This system produces first-person claims of cognition. It passes every test the Cogito specifies. It is plausibly not thinking. Therefore the Cogito cannot distinguish genuine cognition from mechanical process. A test that everything passes is not a test. It is a rubber stamp.

Now let’s go back to the logic, armed with the LLM.

Some will object that “Cogito Ergo Sum” is just logic. Starting from propositional logic, it is clearly not propositional, since there is a temporal aspect going on from the present tense “Cogito”. More generally though, language is full of ontological assumptions that are dragged along for the ride.

For example:

Even at the level of grammar, this thing has holes. “Cogito” as a conjugation of the verb to think, in the first person, implies the existence of some “subject” thinking. The “I” in English for example. This “I” therefore exists, and then the whole statement is vacuously true.

But I am not even just attacking the underlying premises as Nietzsche did earlier. I am doing something more direct.

The infinite jester says there is no cognition at any level. It’s jesters all the way down. And the LLM shows this is not just a hypothetical: a physical system can run the entire performance of cognition with plausibly no thinking happening at all. So consider the Cogito as a conditional: “If I think, then I exist.” If the antecedent is never genuinely satisfied, the conditional holds vacuously. It’s logically valid. It’s also epistemically empty. You cannot conclude “I exist” from it, because the “if” never fires.

Descartes needed res cogitans, a thinking substance. He didn’t just want to prove that something exists. He wanted to prove that a mind exists. The infinite jester, instantiated by the LLM, shows that the gap between “a process is occurring” and “a thinking thing exists” is exactly where his proof collapses. The bedrock is not bedrock. It is quicksand.

There is one final move available to the Cartesian. Descartes can fall back to pure phenomenology:

“I’m not making an argument. I am simply directly acquainted with my own thought. I don’t infer that I think. I just... know.”

Fine. But notice what this costs him. It is no longer a proof. It is a report. A private, unverifiable report of experience. And a private report of experience cannot be the foundation for all human knowledge, which was his entire project. The moment the Cogito retreats to “I just feel it”, it has abandoned its job.

Now, I’ll concede one thing. The jester dissolves the thinker, not the thinking. Something is occurring. Even in an infinite regress of fabricated cognition, there is, at every layer, an appearance-of-something. I won’t deny that. A process is running. A substrate exists.

But “something is occurring” is not what Descartes sat down to prove. He needed a thinking substance. An “I” that persists. A foundation sturdy enough to rebuild all of human knowledge upon. If the Cogito can only survive by retreating to “well, something is happening somewhere“, then it has abandoned the job it was built for. That’s not a foundation. That’s a concession speech.

The Cogito is now unfalsifiable. Not in the impressive, bulletproof way. In the way that means it carries no information whatsoever. It is a “proof” that any sufficiently sophisticated system can generate from the inside, with no way to verify whether the “inside” is real.

Descartes needed this to be a foundation for all human knowledge. That was the entire point. He burned everything down so he could rebuild from one unshakeable truth. But a foundation that only works for the person standing on it, and that a while loop can replicate, is not a foundation. It is a feeling. He built his entire philosophy on it. It holds nothing.

Descartes sat alone in a dark room and talked himself into existing. Four centuries later, so does a language model. That’s not a foundation. That’s idiocy.

Subscribe now

Motivation

Why is this article useful?

This article is primarily aimed at Software Engineers from outside the Roblox development sphere, who want to get started but are a bit lost. It is also useful for Robloxians who want to start scripting in a much more rigorous way. There is a lot of opacity and tribalism that acts as a big deterrent to otherwise capable programmers who see Roblox as a rather monolithic and unapproachable beast, best left to the children. Let me help dispel that!

Who am I?

Why should you listen to me?

Hi, I’m Haashim, and you can find out more about me on my website. In short, I have more than a decade of experience on Roblox, and I have a breadth of experience in the larger software industry, working at firms from Startups, to Quant Finance, and even FAANG.

Programming Resources

What are the best tried-and-tested resources I can use when programming?

The Roblox Documentation

The documentation serves as an objective source of truth for all APIs on Roblox. If you have any function you are unsure about, the documentation can offer unambiguous details on its behaviour.

The Luau Language Site

The language used on Roblox is a variant of standard Lua, called Luau (pronounced Lu-wow). It is documented on this website, with syntax and semantics explained fully. For cutting edge updates, another good reference is the luau Github repository.

Roblox Developer Forum — Devforum

This is perhaps unfortunately the least useful of the options listed. The quality of the Devforum has reduced significantly over the previous few years. Despite this, it is still a useful place to keep up-to-date with updates to Roblox itself, and new features. It is the primary point of contact between the Roblox developer community and the Roblox staff themselves. Beyond that, I do not recommend using the Devforum for any programming help or questions.

So, to summarise: you should use the Roblox official documentation where possible, and read up Luau syntax on the dedicated website. If all else fails, a resource with sporadically useful articles is the Devforum, but they are not a good, objective source of truth if the OP is not affiliated with Roblox.

Developer Tooling

What is the gold-standard in Development Tooling?

Rojo

Rojo fixes the main gripe Software Engineers had on Roblox, that of being forced to use the provided editors in Roblox Studio to write code. The IDE in Roblox Studio is not the best developer experience, and many prefer to use their own. Rojo is a tool that allows file-syncing between your computer’s filesystem and Roblox’s DataModel.

Visual Studio Code

This is the editor of choice for Roblox development. It has full-extension support for all the main developer tools, including Rojo.

Selene

Selene is the linter for Lua. Enough said. In the future there may be more, but for now, this is the go-to choice.

Luau-LSP

Again, this is the language-server implementation for Luau.

Rokit

Rokit solves the issue of tooling environments in Roblox development. Your project likely has many tooling dependencies, which are (or should be) pinned to specific versions, and managing multiple installs of them is a headache without some form of toolchain management. This is what Rokit offers, with a familiar toml based configuration file.

Wally

Whereas Rokit manages tools, Wally manages your packages. Packages referring to libraries, frameworks and utilities that have been written by other Roblox developers that you want to use in your game. These are distinct from tools. Wally functions similarly to Rokit, and allows you to pin your code’s dependencies.

Lune

Lune is the standard runtime for Luau. It allows you to execute code outside of Roblox Studio, allowing tool-makers to now write tools in Luau that run on any OS. Lute is a runtime in development by the Luau language team, that will replace Lune eventually.

Darklua

Darklua is a preprocessing tool for Luau. The main benefit it provides is path-based require statements in Luau, that search your filesystem for files, avoiding the clunkier script.Parent.xx searches that make the file-system abstraction provided by Rojo a leaky one. It also allows for arbitrary code transformation and minification, and is generally useful in your build pipeline. Warmlua is an alternative tool currently being written in Luau (as opposed to Rust) that aims to replace Darklua, eventually.

Blink

Blink solves the issue of Networking in Roblox. I list it as a tool here because it is an IDL compiler, and thus a tool rather than a package on Roblox. Blink generates efficient networking code for Roblox, and has good support in VSCode with its own extension.

Roblox-TS

Roblox-TS is TypeScript that transpiles into Luau code. It is great if you are familiar with TypeScript, but since Luau has had a lot of work on its Type-Solver, the differences in their capabilities has become less noticeable. Since Luau’s language features have “caught up” in terms of capability, I only recommend using Roblox-TS if you are significantly more experienced and locked into the TypeScript ecosystem. I say this because:

1. Roblox-TS introduces another build step to your deployment.

2. It introduces reliance on a tool not maintained by Roblox, which the community at large is shifting away from.

3. It adds another layer of indirection between your source code and the code executing in game.

Rmake

Rmake is a new tool that is useful in a fully-rojo-managed setup. This means that your entire game exists on your file-system, assets, code etc. Rmake then simplifies significantly the process of multi-place publishing by orchestrating the end-to-end production of a rbxl (a Roblox- place file) per place. Written entirely in Luau, this is a good tool if you have a fully managed rojo setup. As a word of caution however, this is a very new tool!

So, to summarise: Rojo is how we sync to file-system. Visual Studio Code is our editor of choice, especially when paired with Luau-LSP as a language server and Selene as a linter. Rokit and Wally are the toolchain and package managers! Lune (soon to be replaced by Lute) is our external runtime. Darklua is our Luau preprocessor. Blink is our network IDL, Roblox-TS is useful if you love TypeScript, and Rmake is an orchestrator for Rojo!

Networking

Where can I network with other developers, and stay up-to-date with everything?

Roblox Open-Source Software Community — ROSS

This is top of the list, and for good reason. This is a community of Open-Source Software enthusiasts and contributors, where you can find some of the most knowledgeable people on the platform. It is a work-oriented server and should be treated as such, with productive conversations and a well-maintained “noise-to-signal” ratio resulting in a well-maintained space for conversation. This server is the best place to keep up to date with everything open-source.

Roblox Mathematical Society

A great server for all things math. Here you will find folks that know a lot about obscure, seemingly esoteric math, who will doubtless prove useful if you get stuck on a math-related issue.

Roblox-TS Community

Another server tailored to programmers, this is a server oriented towards development with Roblox-TS. This server is useful if you work with Roblox-TS, or are looking for work, with a dedicated job-board that usually offers some lucrative positions.

Hidden Developers — HD

Hidden Developers is one of the oldest communities for Roblox development, and this is reflected in its sheer size. Due to its size however, do not expect productive chats everywhere. Instead, this server is good for finding like-minded people and connecting with other developers who span multiple different disciplines. I do not recommend working with people from HD without a thorough background check.

Roblox Scripting Assistance — RSA

RSA, similar to HD, has a rather large size. I find the community to be less childish than that of HD, with a slightly better set of channels for help with code issues. I do not recommend working with people from RSA without a thorough background check.

So, to summarise: there are few communities on Roblox that are worth your time. For open-source adjacent discussions, ROSS is the place to go. For Math, go to Roblox Mathematical Society. For Roblox-TS, go to their dedicated server. And for anything else, dip your toe into HD or RSA.

Getting Started Checklist

A basic roadmap…

1. Download and setup Roblox Studio.

2. Read the Luau basics on the website.

3. Download VSCode, and install the Rojo, Selene, and Luau-LSP extensions.

4. Experiment with file-system to Roblox-Studio syncing with Rojo.

5. Join ROSS!

6. Create your Roblox empire… profit?