Two reference numbers enter an AI-assisted workflow. Two records come out. The file opens, the record count agrees and no error appears. Yet the two references now look identical. A check that counted rows would miss the change that matters most: which record is which.
This can happen when a long identifier is treated as an ordinary JavaScript number. For creators and small business owners moving information between tools, the practical lesson is to agree how identifiers travel before asking an assistant to convert the data. Digits do not automatically mean a quantity that should be calculated.
Start with what the field means
A quantity answers a question such as how many copies are required. An identifier answers which order, asset or record is involved. Those roles deserve separate treatment, even when both fields contain only digits.
Consider a fictional studio handing over two asset records. Their references are 9007199254740992 and 9007199254740993. These deliberately chosen values make a technical boundary visible; they are not real customer references or evidence of a particular platform failure. The studio needs each exact reference to survive the handover.
Before changing anything, inspect the receiving system’s documented field type. If it accepts an identifier as a string, preserve it as text throughout the route. If it requires a number, investigate its supported range and the representations used by intermediate tools. Merely adding quotation marks to an incompatible interface is not a complete repair.
JSON syntax does not guarantee exact numeric identity
The JSON standard, RFC 8259, published in December 2017, allows implementations to limit numeric range and precision. Its interoperability guidance identifies the integer range from −(2⁵³ − 1) to 2⁵³ − 1 as one in which widely used binary64 implementations agree exactly. A syntactically acceptable number can therefore require more precision than a receiving implementation provides.
For JavaScript, the ECMAScript 2025 specification’s Number.MAX_SAFE_INTEGER entry defines the positive safe-integer boundary as 2⁵³ − 1, or 9007199254740991. Beyond that boundary, distinct integers can share a Number value. This does not mean every larger integer is inexact; it means exact distinctions between neighbouring integers are no longer generally safe to assume.
These are established format and language rules, not a newly discovered AI defect. An assistant can still introduce the problem by choosing an unsuitable representation or generating a conversion that never checks the field’s meaning.
A checked two-record example
For this article, an isolated JavaScript check parsed the following fictional JSON text using the ordinary JSON.parse operation:
[{"reference":9007199254740992},{"reference":9007199254740993}]
Serialising the parsed result back to JSON produced:
[{"reference":9007199254740992},{"reference":9007199254740992}]
The second reference had changed. Comparing the two parsed reference values returned equality, and putting them into a set produced one unique value. The array still contained two records. A successful parse and a matching record count therefore provided no assurance that the identifiers remained distinct.
The check then parsed a version whose references were strings from the outset:
[{"reference":"9007199254740992"},{"reference":"9007199254740993"}]
Both exact strings survived serialisation, and the set contained two unique references. These results describe this small JavaScript experiment. No studio database, customer account or commercial import service was accessed. A destination may apply further conversions, so the result is not a promise about every application.
Converting afterwards is too late
One tempting repair is to parse the numeric version first, then turn each resulting number into text. In the same check, that produced the strings "9007199254740992" and "9007199254740992". Changing the type after the distinction was lost did not recover the original second reference.
This is why the untouched source matters. If a converted copy has already collapsed the identifiers, return to an authoritative source containing the original values. Do not guess a missing final digit from the surrounding sequence. Consecutive-looking references do not establish what any particular original reference was.
The point of intervention should be before an unsuitable numeric conversion. Where the source and destination require a different representation, have the developer document a lossless route and verify it with boundary cases. The owner’s requirement can remain simple: every reference must arrive exactly as issued.
Give the assistant a preservation requirement
A useful instruction for the fictional studio would be: “Treat reference as an identifier. Preserve every character from the original source. Do not convert it to a JavaScript Number. Check the destination’s documented type before proposing a change. Show how the two supplied references remain different after import and export.”
That instruction identifies the desired behaviour without pretending to specify every application’s implementation. It also gives the assistant something concrete to demonstrate. Asking only for clean JSON or a tidy export leaves the most important acceptance condition unstated.
Keep genuine quantities separate in the brief. A request to preserve reference fields as text does not require every count or measurement to become text. Field roles and destination requirements should drive the decision.
Verify the whole route
For a small handover, I would ask for the following evidence:
- An untouched source copy and a clear definition of which fields identify records.
- A documented type for each identifier at the source, conversion stage and destination.
- A comparison of exact reference strings before and after the real import and export route.
- Checks for changed values and unexpected collisions, alongside record counts.
- A completion note naming the tested route and any stage that remains unverified.
A collision check is useful only where references are expected to be unique; some datasets legitimately repeat a reference across several rows. Compare the identifiers against their intended role rather than declaring every repetition an error. Likewise, checking only a displayed preview is weaker than inspecting the values actually handed onwards.
MaryChuks’ guide to repeated names in JSON objects addresses another way a successful parse can conceal a change in meaning. The present issue is different: distinct source values can collapse during numeric conversion. Both deserve a check before the parsed result becomes the trusted copy.
For the studio, the final question is practical: can each returned reference still identify the intended original asset? That is the result to demonstrate. A file that opens successfully is a useful beginning, but identity needs its own evidence.
Sources
- RFC 8259 — December 2017, section 6 on JSON numbers and precision.
- ECMAScript 2025, Number.MAX_SAFE_INTEGER — the language specification’s safe-integer boundary.
- ECMAScript 2025, JSON.parse — parsing structured JSON data. Sources checked 30 October 2026.
Discover more from Marychuks.com AI, Psychology, Business & CreativeVerse
Subscribe to get the latest posts sent to your email.
One thought on “AI JSON Handover: Keep Long Identifiers Exact”