Best C# technique to pass variable from Instantiated object to GameObject

public float infoToSend; // This is a public member variable, also called a field.

void Update(){
    float infoToSend = 10f; // This is a local variable that exists only in this function.
}

When you start a variable assignment with a type, like float, you're telling the compiler, "hey, I'm defining a new variable of type float here. So, forget about any member variables I might have defined with that name for the time being - as long as we're inside this Update() method, the name infoToSend will refer to this local variable instead."

(If you did this deliberately, and you want to refer to the infoToSend at member scope instead of the local infoToSend in the method's scope, you can say this.infoToSend to specify that you're talking about the member variable)

So, in this case, you've never assigned the value of 10 to your public field. You assigned it only to a local variable, that gets thrown out as soon as the function completes (you'll get a warning from the compiler about this, if you've assigned a variable without ever using it anywhere).

This is called variable shadowing, and it's a fundamental part of the language syntax that's not specific to game development. If you're unfamiliar with the basics of C# syntax, then it might be best to brush up with some introductory tutorials before proceeding.

If you just want to assign a value to a variable you've previously declared, you don't start the line with the type - the compiler already knows the type from its original declaration. So you can just say:

infoToSend = 10f;

This says "assign the value of 10 to my existing variable infoToSend, without declaring a new variable at this scope."

The foregoing fixes the particular code you wrote, but it's generally considered poor programming practice to expose everything as public variables. When they're public, any code anywhere could modify them, so if you get a bug from the variable holding the wrong value, it's more challenging to track down where it came from. We say techniques like this "increase the surface area for bugs."

So, if you have a strict relationship where your prefab object publishes this data, and other scripts consume it, you should enforce that relationship in your code.

A classic way is to make a getter function:

float infoToSend;
public float GetInfo() { return infoToSend; }

Now only this script can change infoToSend's value, while anyone can read it. This is so popular, C# has a shorcut for writing this kind of relationship, through what are called "auto properties":

public float infoToSend {get; private set;}

This makes a publicly readable variable that only the local script can set. It's really just syntactic sugar on a private setter / public getter method, but it's short to type and makes your intention clear.

You could also use Events to send this type of information when it's updated - a push relationship instead of a pull - adding or removing subscribers as needed.