How to ignore enum variant when serializing

Question

Given the following example, I would like to encode an enum using bincode into a custom format. As an example, I am trying to encode strings with the length first as a single bytee:

#[derive(Debug)]
enum Value {
    MyString(String),
}
impl Serialize for Value {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let mut buffer: Vec<u8> = Vec::new();
        match self {
            Value::MyString(s) => {
                let bytes = s.as_bytes();
                let length = (bytes.len() as u8).to_be_bytes();
                buffer.extend_from_slice(&length);
                buffer.extend_from_slice(bytes);
                println!("{buffer:?}"); // [1, 97]
                serializer.serialize_bytes(&buffer)
            }
        }
    }
}

However when I call serialise on it I get the variant encoded first as u32:

fn main() {
    let value = Value::ShortString("a".into());
    let encoded = bincode::serialize(&value).unwrap();
    println!("{encoded:?}");
}

Such that encoded == [2, 0, 0, 0, 0, 0, 0, 0, 1, 97] where as I want to ignore the variant such that encoded == [1, 97]

Is anyone aware of how this can be done?