ABOUT THIS vs THAT

: Why Use It? What Does It Do?

CompareThisThat™ is not merely a clever diff tool. It is a meaning-change instrument.

People currently search documents by manually looking for changes in intent, or rely on “looks similar” tools which only reveal superficial surface shifts. CompareThisThat gives you precise and isolated readable answers to the thing you actually care about:

→ Was it cosmetic, structural, or semantic?

→ Did risk, obligation, permission, timing, or the control shift?

→ Is the difference benign, a hidden-risk, or a meaningful break?

→ Can the result be easily explained and quickly evidenced?

Everyone knows how tedious and exhausting closely reading and comparing documents that appear similar is. Often such detailed focus detracts from the actual workflow at hand. We could make assumptions, we might give up, or if we do dedicate the time, we soon find ourselves starting to skim over nuances, potentially opening ourselves up to costly mistakes from missing important details, issuing wrong or altered obligations, or just blindly accepting unknown changes.

➤ This is especially true with technical formats and nuanced small-print.

➤ The building trades know the reality of shifting specifications and the subsequent spiralling costs of plans altering mid-task. It can waste labour, blow budgets, and be the root of disputes. [OCR, image, visual, CAD and schematic interpretation unavailable at launch]

➤ AI agents easily drift when steps start to change literal meaning, and coders themselves can fall foul of semantic shifts when changes, however subtle, may have altered intent and permissions — all creating downstream issues.

: What Is This≠That™?

CompareThis≠That™ enables both users and AI agent systems to instantly and deterministically recognise when the flow of intent has altered between two comparable items, even when the evidence appears close.

This is not common superficial surface difference detection. It determines whether two inputs are meaningfully the same, or meaningfully different under explicit constraints, providing a rapid and reliable auditable way to enforce semantic distinction in complex workflows, where correctness depends on the precise intent, not a resemblance.

It presents immediate notice of any alterations, and for AI systems; to move beyond similarity and to establish if there is semantic distinction, equivalence, or conflict before decision execution or storage occurs.

➤ This≠That is intended for use where “almost the same” is simply not acceptable.

➤ When precise meaning and consistency matters, all differences must surface and be made explicit.

➤ Apparent large changes might be irrelevant, whereas an overlooked subtle slight change could be critical.

By providing comparison under constraint, CompareThis≠That immediately and easily draws attention to answer questions such as:

• Are these two inputs meaningfully equivalent?
• Has the intent changed anywhere in any material way?
• Is this substitution allowed under defined rules?

Rather than returning a similarity score alone, This≠That returns a bounded semantic judgement suitable for downstream enforcements...

...because by not catching small shifts in intent early, ignored inflections can greatly alter downstream behaviour.

: The Problem Solved

: Beyond Typical Text Diff

Traditional diff tooling compares surface forms: Characters | Tokens | Lines | Structure - which is effective for stating what superficially has changed, but not what it means or more so, has the meaning / the intent of will changed?

This≠That™ operates at the Maenen Labs' level of meaning. It evaluates whether two inputs are:

• Meaningfully equivalent or meaningfully different,
• or in conflict under explicit constraints.
• Unsafe substitutions
• Untraceable decisions

The Diff Distinction

: How Will It Work with Prose or Code?

Firstly, it is not confined to strict line-by-line diff comparison.

For prose and code-like files, it first normalises the content and compares meaningful units, then will surface change at clause, phrase, token-window, or line level. So a topic/claim can still be recognised when it has moved to another paragraph or further distance through the second document.

An important boundary to note: it is not an unlimited “find every concept everywhere” semantic search. If the moved topic is also heavily rewritten, shortened, or dispersed across several distant passages, the engine may correctly treat it as a removal plus an addition/change rather than falsely insist it is the same anchored claim. That is prudence, not weakness.

Structured material is stronger still:

➤ JSON: compares flattened key/value identity.

➤ CSV/TSV: compares identified rows and fields.

➤ Provenance links only point to a source block when the match is proven; it deliberately will not guess the nearest-looking paragraph.

: About Code Compare Artefacts

CompareThisThat is especially strong for explicit operational claims such as:

deployment.require_validation_success = true

becoming:

deployment.require_validation_success = false

...or any changes to:

→ permissions, auth scopes and security controls
→ boolean safeguards and feature flags
→ numeric limits, dates, thresholds and timeouts
→ configuration values and nested JSON keys
→ negation, obligation, or modal changes (must, required, disabled, etc.)

Those are not merely visual differences: the comparison preserves signals such as numbers, dates, negation, security/control terms, and modal shifts, so it can classify a clear control reversal as a substantive meaning break rather than “some code changed.”

It can also ground retained .py / .js excerpts through exact containment, and structured code/config inputs through key identity.

What it does not yet claim to do is prove runtime equivalence across a whole program: following calls through multiple modules, resolving aliases, understanding dynamic values, or recognising a large refactor as behaviourally identical. Currently the engine is code-aware textual/structural comparison — not full program analysis.

: What This≠That™ Is NOT

Whilst this tool offers immediate relief and a 'speed-read mindfulness' to comparision checking — it must be realised that intentionally is not designed to claim that any flagged differences of intent are either right or wrong, nor that they will or not work.

That is only for you to decide — to accept, or to reject.

To ever make the claim that 'this will or will not work' etc is too much of an ask - as context and evaluation of application is for you to assess. What is does provide is a rapid clarity on matters that may have otherwise gone overlooked and subsequently felt later.

: Public Beta Usage Notice

This new service is currently in public beta. Usage may be subject to rate and payload upload limits, and features may change as the service evolves. Please review the Documentation and Terms & Privacy before use.

: Support & Feedback

Support is currently limited during public beta. Questions and feedback are welcome, though response times are not guaranteed.
If you have observations, edge cases, or questions about use we will be happy to hear from you. All feedback is reviewed. Please include:

• A short description of the issue.
• Example payloads (if possible and not sensitive / private).
• The receipt from the relevant request.