Text.text = int + X?

I'd solve this problem using something similar to this:

private static ReadOnlySpan<string> _skyBiomes => new[]
{
    "(Empty first)",
    "Dark Sky",
    "Cold Sky",
    "Dusty Sky",
    "#4",
    "#5",
    "#6",
    "#7",
    "#8",
    "(Empty last)",
};

private void SetSkyBiomeType(int skyBiomeType)
{
    var skyBiomes = _skyBiomes;
    skyBiomeType = Mathf.Clamp(skyBiomeType, 1, skyBiomes.Length - 2);

    SkyPreviousBiomeType.text = skyBiomes[skyBiomeType - 1];
    SkyBiomeType.text = skyBiomes[skyBiomeType];
    SkyNextBiomeType.text = skyBiomes[skyBiomeType + 1];
}

Create a dictionary with key int and value of string and store it via some ScriptableObject that is accessible to your scripts. Key should be biome ID and value should be BiomeText.

See: https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.dictionary-2?view=net-9.0

Then access the dictionary instead.

int currBiome = i
...
skyPreviousBiomeType.Text = biomes[currBiome-1];
skyBiomeType.text = biomes[currBiome];
skyNextBiomeType.text = biomes[skyBiomeType+1];

Obviously, this is not a bulletproof solution.
You would preferably need to check if the key is in the dictionary and if not, apply some other custom logic of your choice to select the Biome.
Example problem could occur when your currBiome is 1; what would be the previous Biome then? Do you stay at 1 or does it underflow into 8?

You can simply use a string array for the biome types. By inserting extra empty strings at the beginning and at the end, we ensure that we always get a result for the previous and next biome. This also ensures that the first real biome is at index = 1.

private static readonly string[] _biomTypes = { "", "Dark Sky", "Cold Sky", "Dusty Sky", "five more types...", "" };

private void SetSkyBiomeType(int skyBiomeType)
{
    skyBiomeType = Mathf.Clamp(skyBiomeType, 1, 8);

    SkyBiomeType.text = _biomTypes[skyBiomeType];
    SkyPreviousBiomeType.text = _biomTypes[skyBiomeType - 1];
    SkyNextBiomeType.text = _biomTypes[skyBiomeType + 1];
}

No if-statements required.

By making the array static, we ensure that it will be instantiated only once.

Try wrapping the sky biome and use a - and + override. This way you can have different biome types such as LandBiome : IBiomeType and WaterBiome : IBiomeType

public interface IBiomeType
{
    public string Name { get; }
}
public struct SkyBiome : IBiomeType
{
    public readonly string Name
    {
        get => BiomeNames[_value];
    }

    //Add all of your Sky Biome Names here
    private static readonly List<string> BiomeNames 
        = ["Dusty Sky", "Sunny Sky", "Clear Sky", "Cloudy Sky"];
    private int _value;
    public static readonly SkyBiome Dusty = new() {_value = BiomeNames.IndexOf("Dusty Sky")};
    public static readonly SkyBiome Sunny = new() { _value = BiomeNames.IndexOf("Sunny Sky") };
    public static readonly SkyBiome Clear = new() { _value = BiomeNames.IndexOf("Clear Sky") };
    public static readonly SkyBiome Cloudy = new() { _value = BiomeNames.IndexOf("Cloudy Sky") };
    public override readonly int GetHashCode()
    {
        return HashCode.Combine(Name, _value);
    }
    public override readonly bool Equals([NotNullWhen(true)] object? obj)
    {
        return obj is SkyBiome other && other.Name == Name;
    }
    public override readonly string ToString()
    {
        return $"{nameof(SkyBiome)}[ {Name} ]";
    }
    public static SkyBiome operator -(SkyBiome skyBiome)
    {
        --skyBiome._value;
        if (skyBiome._value < 0) skyBiome._value = BiomeNames.Count - 1;            
        return skyBiome;            
    }

    /// <summary>
    /// Gets the next <see cref="SkyBiome"/>
    /// </summary>        
    public SkyBiome GetNextSkyBiome()
    {
        SkyBiome skyBiome = new() { _value = _value };
        return +skyBiome;
    }

    /// <summary>
    /// Gets the previous <see cref="SkyBiome"/>
    /// </summary>        
    public SkyBiome GetPreviousSkyBiome()
    {          
        //the - and + operators directly effect the current SkyBiome
        SkyBiome skyBiome = new() { _value = _value};
        return -skyBiome;
    }

    public static SkyBiome operator +(SkyBiome skyBiome)
    {
        ++skyBiome._value;
        if (skyBiome._value >= BiomeNames.Count) skyBiome._value = 0;
        return skyBiome;            
    }

    public static bool operator ==(SkyBiome left, SkyBiome right)
    {
        return left.Equals(right);
    }

    public static bool operator !=(SkyBiome left, SkyBiome right)
    {
        return !(left == right);
    }
}

People have already posted the best solutions that applies to your problems, and solves it. But let's analyze whey they work.

So what you want is a biomeType which is a string in your case, that can be represented by a number aka int. Following this logic you would have below list of biomes.

0. " ",
1. "Dark Sky",
2. "Cold Sky",
3. "Dusty Sky",
.
.
n. "Nth Biome"

This is a classic requirement for Dictionary where you can have int as a key which represents one of your biomes, and type of the biome a string can be set as a value represented by a unique int key.

But notice one thing that all your keys or int values are sequential and starts from 0. Here using an array makes much more sense as arrays are much simpler and faster then a Dictionary. Arrays are also seializable by unity and can be updated directly from an inspector window. Using incidences from 0 to n as your key you can represent as much biomes as you need.

Well now you can follow Olivier Jacot-Descombes's answer

You can also use a List<T> if you want to make your biome callection more dynamic. And everything I saied about an array also applies for a List<T> as well.

A lot of solutions here like using a switch case or dictionary are a bit overkill. Also Unity can't serialize the dictionary and other collection types out of the box.

This is basically purely index-based so no need for a Dictionary, a simple array or list can already handle this and these are the two collection types that Unity can serialize out of the box.

=> Simply have and fill a string[] accordingly

Then I would prefer to not Clamp but rather wrap around the index so if the index goes beyond the maximum index of the array it simply starts from 0. And the other way round if it falls below 0 it starts at the end of the array. This way you don't even have to worry about disabling the next and previous functionality in case the index is at one of the limits.

I would recommend to do something like

// This gets exposed so you can modify it in the Inspector of the component
[SerializeField] private string[] skyBiomTypes;

// Wraps around the index at the ends
// meaning if the index becomes larger than the array allows it starts again from 0
// and the same for the other direction if falling below 0 it starts from the end
private int IndexWrapAround(int index) 
{
    int r = index % skyBiomeTypes.Length;
    return r < 0 ? r + skyBiomeTypes.Length : r;
}

private void SetSkyBiomeType(int skyBiomeType)
{
    // at this point either already wrap around the index 
    skyBiomeType = IndexWrapAround(skyBiomeType);
    // or stick to clamp according to your needs
    // In the case of clamp though make sure the Indices are actually valid
    //skyBiomeType = Mathf.Clamp(0, skyBiomeTypes.Length - 1);
    
    // Use wrap around indices in both directions so that next or previous 
    // will not fail if index is at min or max
    SkyPreviousBiomeType.text = skyBiomeTypes[IndexWrapAround(skyBiomeType - 1)];
    SkyBiomeType.text = skyBiomeTypes[skyBiomeType];
    SkyNextBiomeType.text = skyBiomeTypes[IndexWrapAround(skyBiomeType + 1)];
}