Why does Royce narrate the opening of a recursive playthrough?

Solution 1:

Since everything in Transistor is presented like code or programming, I think it's fair to look at this from a computer science angle.

So let's look at the game like it's a programming function

In Computer Science, recursion is when a function calls itself in it.

Doing so resets the function to the first line. Thing is, when you do that you need an exit condition. A thing that will stop the code from always just executing the function, getting to the function call and reseting to the beginning of it. At some point you need to have a condition where that function will not call itself again.

So if you look at the game like a linear programming function, the recursion playthrough would be inside the 'Transistor' function, that reset from within itself. And Royce has been put in the Transistor at the end of the first playthrough. So I guess they are showing that recursive playthrough (where one of the differences is that Royce is an 'object' that is present in this run of the Transistor function, but wasn't there in the first run)

Or to put it in linear instructions

Royce doesn't exist within the Transistor. So the boxer (the guy in the Transistor) narrates the line.
The Transistor() function runs through it's course.
All the elements absorbed within the Transistor (item) during the game are objects that are now existing within the Transistor function. (As we can see that the boxer, killed by the transistor, is in fact absorbed and then present within it)
You absorb Royce at the end of the game, and then you 'Recurse', starting the Transistor() function again.
Royce being an element now available, Royces narrates the line.

Or straight write a code approximation of the game's story

var Royce = null;
function Transistor(){
    Boxer.kill();
    if(Royce){
        Royce.NarrateIntro();
    }else{ // Royce being set to null on the first play through, it goes to the else
        Boxer.NarrateIntro();
    }
    SingGreatMusic();
    RideAwesomeMotorcycle();
    ShowCoolGraphics();
    SurfOnCoolCloud();
    Royce = new Character.Royce(); // The character Royce now exists in Transistor()
    Transistor(); // The function is called again, starting back at the beginning.
    //This code probably doesn't run in anything, but is just to illustrate.
}

So that explains on a Programming standpoint. But how about the narrative?

When you start a recursive playthrough, Royce figures out the function is an infinite loop. Everything is the same as at the beginning of the function, except he is now also there.

Why other characters don't figure it out is unknown, but Royce is presented like one of the leaders of Cloudbank, so might be a higher process than Red or the boxer, and so knows more or is more intelligent.

The ending of the first playthrough was a surprise to him, but now he sees we are back at the beginning with the same parameters. So this is a loop. Dang it. So he know Red will just go through it again, kill him again, and reset again. The 'programmer' that coded that function screwed up. There is no exit condition. No point where the function is considered done and the process ends naturally.

So in that context, read the line:

Hey Red... we’re not gonna get away with this are we?

We're not gonna get away with this. We're stuck fighting each other until the process freezes or dies. (And at that point, they stop existing so it's not a win)

TLDR: Errr... Transistor's story is a dramatisation of every time I screw up and create an infinite loop while programming?