Programming a Pristine World Let's define a pristine program as a program that does not have any errors itself but will error if you modify it by removing any contiguous substring of \$N\$ characters, where \$1 \le N &lt; \text{program length}\$.
For example, the three character Python 2 program
`8`

is a pristine program (thanks, Sp) because all the programs resulting from removing substrings of length 1 cause errors (syntax errors in fact, but any type of error will do):
8`
``
`8

and also all the programs resulting from removing substrings of length 2 cause errors:
`
`

If, for example, `8 had been a non-erroring program then `8` would not be pristine because all the results of substring removal must error.
Your task in this challenge is to write the shortest pristine program possible that takes no input but outputs any one of the following five words:
world
earth
globe
planet
sphere

Which word you choose is entirely up to you. The sole word plus an optional trailing newline should be printed to stdout (or your language's closest alternative). The shortest program in bytes wins.
Notes:

A standalone program is required, not a function.
The words are case sensitive; outputting World or EARTH is not allowed.
Compiler warnings do not count as errors.
The erroring subprograms can take input or give output or do anything else as long as they always eventually error.

Here's a stack snippet that will list what programs need to error given a potentially pristine program:


&lt;script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'&gt;&lt;/script&gt;&lt;script&gt;function go() { var s = $('#i').val(), e = []; for (var i = 1; i &lt; s.length; i++) { for (var j = 0; j &lt;= s.length - i; j++) { e.push(s.substring(0, j) + s.substring(j + i)); } } $('#o').val(e.join('\n---\n')); }&lt;/script&gt;Program:&lt;br&gt;&lt;textarea id='i' rows='16' cols='80'&gt;`8`&lt;/textarea&gt;&lt;br&gt;&lt;button onclick='go()' type='button'&gt;Go&lt;/button&gt;&lt;br&gt;&lt;br&gt;Programs that should error: (--- separated)&lt;br&gt;&lt;textarea id='o' rows='16' cols='80'&gt;&lt;/textarea&gt;&lt;br&gt;
Rail, 24 bytes

$'main'    #
 -[world]o/


I think this works. And it's both short and readable (as far as Rail goes).


If the removed substring includes any part of $'main' we get Internal Error: Crash: No 'main' function found.
If the removed substring includes the #, there is no way for the program to exit cleanly, so it will always terminate with Crash: No valid move. I believe that it's not possible to delete a substring such that the track forms a valid (infinite) loop.
If the removed substring is in front of the #, it will be disconnected from the end of the track, so the train will crash (with the same error as above).
If the removed substring is after the #, it will also disconnect the # from the end of the track (and potentially even the beginning of the track from the entry point $). So again the same error.


As for the actual program: every Rail program needs to have a $'main' (or a longer variant, but we're golfing here) as an entry point into the function and the train starts on the $ going South-East. Everything on that first line can be part of the track though, so removing the 'main' the track is:

$          #
 -[world]o/


The - and / are simply pieces of rail which we need to let the train take those 45° turns.

[world] pushes the string world and o prints it. # marks the end of the track - the only way to safely terminate a Rail program.

Interestingly, this solution is only possible because Rail allows the tracks to go through the main line - if that wasn't possible # would be after the first newline and the code could always be shortened to

$'main'
 #


which is a valid program that doesn't do anything. (Non-space characters between ' and # wouldn't affect that.)

Also quite interesting: if I had just golfed the task printing world it wouldn't have been much shorter or simpler:

$'main'
 -[world]o#