How Does Veritula Work? Veritula (Latin for ‘a bit of truth’) can help you live a life guided exclusively by reason. To reason, within any well-defined epistemology, means to follow and apply that epistemology. Unreason, or whim, is an undue departure from it. Epistemology is the study of knowledge – basically, the study of what helps knowledge grow, what hinders…

How Does Veritula Work?

Veritula (Latin for ‘a bit of truth’) can help you live a life guided exclusively by reason.

To reason, within any well-defined epistemology, means to follow and apply that epistemology. Unreason, or whim, is an undue departure from it. Epistemology is the study of knowledge – basically, the study of what helps knowledge grow, what hinders its growth, and related questions.

Veritula follows, and helps you apply, Karl Popper’s epistemology, Critical Rationalism. It’s a continuation of the Athenian tradition of criticism and the only known epistemology without major flaws.¹

Critical Rationalism says that ideas are assumed true until refuted. This approach leaves us free to make bold guesses and use the full arsenal at our disposal to criticize these guesses in order to solve problems, correct errors, and seek truth. It’s a creative and critical approach. Critical Rationalism is a fallibilist philosophy: there is no general criterion of truth to determine with certainty whether any given idea is true or false (Tarski). We all make mistakes, and by an effort, we can correct them to get a little closer to the truth. Rejecting all forms of mysticism and the supernatural, Veritula recognizes that progress is both possible and desirable, and that rational means are the only way to make ongoing progress.

Veritula is a programmatic implementation of Popper’s epistemology.

Veritula provides an objective, partly automated way to tentatively determine whether a given idea is problematic. It does not tell you what to think – it teaches you how to think.

On Veritula, ideas are discrete and immutable. Consider an idea I:

1

              I

Since it has no criticisms, we tentatively consider I unproblematic. It is rational to adopt it and act in accordance with it. Conversely, it would be irrational to reject it, consider it problematic, or act counter to it. (See this quick guide for more details on rational decision-making.)

Next, someone submits a criticism C1:

1
2
3

              I
              |
              C1

The idea I is now considered problematic so long as criticism C1 is not addressed. How do you address it? If you agree with the criticism, you can revise I so that C1 doesn’t apply anymore, which restores the previous state with just the standalone I (now called I2 to indicate the revision):

1
2
3
4

                   Revise
              I ------------> I2
              |
              C1

To track changes, Veritula offers beautiful diffing and version control for ideas.

If you disagree with C, you can counter-criticize it instead, thereby neutralizing it with a new criticism, C2:

1
2
3
4
5

              I
              |
              C1
              |
              C2

Now, I is considered unproblematic again, since C1 is problematic and thus can’t be a decisive criticism anymore.

If you can think of neither a revision of I nor counter-criticism to C1, your only option is to accept that I has been (tentatively) defeated. You should therefore abandon it, which means: stop acting in accordance with it, viewing it as unproblematic, etc.

Since there can be many criticisms (which are also just ideas) and deeply nested counter-criticisms, the result is a tree structure. For example, as a discussion progresses, one of its trees might look like this:

1
2
3
4
5
6
7

              I
           /  |  \
         C11 C12 C13
         / \       \
       C21 C22     C23
                   / \
                 C31 C32

In this tree, I is considered problematic. Although C11 has been neutralized by C21 and C22, C12 still needs to be addressed. In addition, C23 would have neutralized C13, but C31 and C32 make C23 problematic, so C13 makes I problematic as well.

You don’t need to keep track of these relationships manually. Veritula automatically marks ideas accordingly.

Since decision-making follows the same logic as truth-seeking, you can use these trees to make decisions, too. Veritula implements unanimous consent as defined by Taking Children Seriously, a parenting philosophy that builds on Popper’s epistemology. When you’re planning your next move but can’t decide on a city, say, Veritula helps you criticize your ideas and make a rational decision – meaning a decision you’ll be happy with. Again, it’s rational to act in accordance with ideas that have no pending criticisms.

All ideas, including criticisms, should be formulated as concisely as possible, and separate ideas should be submitted separately, even if they’re related. Otherwise, you run the risk of receiving ‘bulk’ criticisms, where a single criticism seems to apply to more content than it actually does.

Again, criticisms are also just ideas, so the same is true for criticisms. Submitting each criticism separately has the benefit of requiring the proponent of an idea to address each criticism individually, not in bulk. If he fails to address even a single criticism, the idea remains problematic and should be rejected.

The more you discuss a given topic, the deeper and wider the tree grows. Some criticisms can apply to multiple ideas in the tree, but that needs to be made explicit by submitting them repeatedly.

Comments that aren’t criticisms – eg follow-up questions or otherwise neutral comments – are considered ancillary ideas. Unlike criticisms, ancillary ideas do not invert their respective parents’ statuses. They are neutral.

One of the main benefits of Veritula is that the status of any idea in a discussion can be seen at a glance. If you are new to a much-discussed topic, adopt the displayed status of the ideas involved: if they are marked problematic, reject them; if they are not, adopt them.

Therefore, Veritula acts as a dictionary for ideas.

One of the problems of our age is that people have same discussions over and over again. Part of the reason is widespread irrationality, expressed in the unwillingness to change one’s mind; another is that it’s simply difficult to remember or know what’s true and what isn’t. Discussion trees can get complex, so people shouldn’t blindly trust their judgment of whether some idea is true or problematic, whether nested criticisms have been neutralized or not. Going off of memory is too error prone.

Veritula solves this problem: it makes discussion trees explicit so you don’t have to remember each idea and its relation to other ideas. Veritula therefore also enables you to hold irrational people accountable: if an idea has pending criticisms, the rational approach is to either abandon it or to save it by revising it or addressing all pending criticisms.

Many people don’t like to concede an argument. But with Veritula, no concessions are necessary. The site just shows you who’s right.

Using Veritula, we may discover a bit of truth.

Still have questions about rationality? Read the technical paper, learn about Veritula’s recursive epistemology and how to structure discussions, or read the quick guide to rational decision-making.

Want personalized help tailored to your own specific needs? Hire Dennis, founder of Veritula, for personal tutoring, or run a bounty.

Rational Decision-Making It’s rational to adopt only those ideas which, as written, don’t have pending criticisms, and to reject ideas that do. If an idea, as written, has no pending criticisms, it’s rational to adopt it and irrational to reject it. What reason could you have to reject it? If it has no pending criticisms, then either no reasons to…

Rational Decision-Making

It’s rational to adopt only those ideas which, as written, don’t have pending criticisms, and to reject ideas that do.

If an idea, as written, has no pending criticisms, it’s rational to adopt it and irrational to reject it. What reason could you have to reject it? If it has no pending criticisms, then either no reasons to reject it (ie, criticisms) have been suggested or all suggested reasons have been addressed already.

If an idea, as written, does have pending criticisms, it’s irrational to adopt it and rational to reject it – by reference to those criticisms. What reason could you have to ignore the pending criticisms and adopt it anyway? After all, the previous paragraph applies to pending criticisms, too.

See also:

• More details and reasoning
• Computational implementation

…its preview shows the code, highlighted: Email notifications highlight code as well. Refer to another idea by its number, like #5114, and it links there. Your idea also shows up on the referred idea’s page, much like GitHub’s ‘mentioned this’ links. Put money on it Want more eyes on your code snippet? Offer a bounty for criticism, like a bug…

Veritula for Programmers

Programmers already know the rule Veritula runs on. A pull request with unresolved review comments shouldn’t get merged. On Veritula, an idea is rationally adoptable only if it has no pending criticisms, and a criticism is pending if it has no pending criticisms itself. Code is an idea like any other, so you can post it, criticize it, and improve it here.

GitHub and GitLab only go so far with that rule, though. You can comment on a gist, but not on a line of it. You can comment on a line of a pull request, but not on half of one. And a thread ends when someone clicks ‘Resolve conversation’, whether or not anyone answered it. Replies in GitHub discussions can’t even be deeply nested (more on that below). Veritula, on the other hand, is built around the simple rule above. Here’s what that means for your code.

Post a snippet, beautifully highlighted

Veritula doesn’t host repositories, at least not yet. It’s for snippets: the function, pattern, or fix you want criticized, with your reasons around it. Unlike GitHub gists, Veritula snippets can be surrounded by prose. Write a sentence or two, put your code between three backticks, name its language, and post. Veritula highlights over 200 languages, numbers the lines, and adds a button to copy the code. Here’s a function to try it on:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Calls `call` until it succeeds, waiting twice as
// long after each failure
async function retry(call, attempts = 5, delay = 500) {
  for (let attempt = 0; attempt < attempts; attempt++) {
    try {
      return await call();
    } catch (error) {
      if (attempt === attempts - 1) throw error;
      await sleep(delay * 2 ** attempt);
    }
  }
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

The editor above has all the features you’ve come to know and love as a programmer. It colors code as you type, the same way the final page will: what you see is what you get. Tab indents and Shift-Tab outdents. Return keeps the line’s indentation, and indents further after an opening bracket, Ruby’s do, or Python’s colon. ⌘/ comments lines out, ⌥↑ and ⌥↓ move them, and pasted code lands at the caret’s indentation. Put your cursor next to a parenthesis or bracket and it highlights the matching one. What you write is saved as a draft as you go, and ⌘S saves it right away. Code you need to keep private can go in a private discussion, which costs a one-time USD 3.00.

Criticize code, with unmatched precision

GitHub ties a review comment to whole lines. That’s a rather blunt tool. On Veritula, you select exactly what you mean – one keyword, half an expression, or a passage across several lines – and choose ‘Criticize…’ from the menu that appears. Your criticism opens with that code quoted, in the same colors it has in the block, even if your selection starts in the middle of a string or a comment.

Once submitted, the passage is marked in the original: red for pending criticisms, gray for addressed criticisms and comments. Hover over a marked passage to see the replies that quote it; click it to go to them. Hovering over a quote does the reverse, and clicking it takes you back to the corresponding part of the code.

The retry function above, once three readers have replied: a pending criticism of how it catches errors, a comment, and an addressed criticism of its numbers.

No button resolves a criticism – the rule does, automatically

On GitHub and GitLab, a thread is resolved when someone clicks a button. Veritula has no such button. A criticism of your code stands until it’s addressed with a counter-criticism or a revision. That answer can be criticized in turn, as deep as the argument goes, and whether your code is rationally adoptable follows from the whole tree, worked out the same way at every level.

Review threads on GitHub are flat: every reply goes at the end of one list. But Veritula is deeply nested: every reply can get replies of its own, so two objections to the same answer don’t get tangled up with each other and criticisms are evaluated recursively.

Revisions that know what they addressed

When a line changes on GitHub, the comments on it are marked ‘Outdated’, whether the change addressed them or not. On Veritula, a revision is a new version, and you choose which replies still apply to it. Those carry over; the criticisms it addressed are credited in it by name, notifying their authors that their criticism led to the change. It’s like naming your reviewers in a commit message, except Veritula does it for you.

Anyone can compare the versions. For code, it’s like a git diff: the lines added and removed, the words that changed within them, and the unchanged lines folded away.

A revision addressing that criticism, compared with the version before it.

When criticisms pile up, a guide takes you through them one at a time. For each, you can address it, revise your idea, or move on for now.

Replay the argument

Each discussion is drawn as a tree beside the text, with pending criticisms in red. A timeline along the bottom of the page goes back through its history, one point for each idea and revision. Drag it back, and the page shows the discussion as it was then: the code before it was revised, and only the replies posted by that time.

The same discussion as a tree. Hollow ideas aren’t rationally adoptable: the retry function (blue) shown through several historical states, with and without pending criticisms.

Share it anywhere

Post a link to an idea with code on X, Slack, or iMessage, and its preview shows the code, highlighted:

Email notifications highlight code as well. Refer to another idea by its number, like #5114, and it links there. Your idea also shows up on the referred idea’s page, much like GitHub’s ‘mentioned this’ links.

Put money on it

Want more eyes on your code snippet? Offer a bounty for criticism, like a bug bounty: name an amount and your terms, and pay out for the criticisms you accept. Others can add their own funding to yours.

Bring your assistant

Veritula has an MCP endpoint at https://veritula.com/mcp. Add it to any coding agent that supports MCP, and it can search and read discussions. Once you sign in, it can also post ideas and replies for you. Everything it posts is properly disclosed as written with AI, automatically.

Try it here

This article is an idea like any other, so the rule applies to it too. If you think the retry function above is wrong, or anything else in this article, select it, choose ‘Criticize…’, and say why. Until someone addresses your criticism, this article isn’t rationally adoptable. The rule decides automatically. It is, in fact, simply expressed in the following code snippet:

1
2
3
4
5
6
7

def should_adopt? idea
  pending_criticisms(idea).none?
end

def pending_criticisms idea
  criticisms(idea).filter { |c| should_adopt?(c) }
end

For more details and a discussion of this rule, see #5114:

Dennis Hackethal·​#5114·​3 months ago

Recursive Epistemology

Veritula implements a recursive epistemology. For a criticism to be pending, it can’t have any pending criticisms itself, and so on, in a deeply nested fashion.

def should_adopt? idea
  pending_criticisms(idea).none?
end

def pending_criticisms idea
  criticisms(idea).filter { |c| should_adopt?(c) }