YAML always as string

main.go

package main

import (
	"fmt"
	"log"
	"strings"

	"gopkg.in/yaml.v2"
)

var data = `
steps:
  - cmd: "hello-world"
  - cmd: bash -c "echo hello-world >> something"
  - cmd: 
    - "test"
    - "image"
`

// StringArray for yaml unmarshalling
type StringArray []string

// Cmd - Command struct
type Cmd struct {
	Cmd StringArray
}

// Task - holder of steps
type Task struct {
	Steps []Cmd `yaml:",flow"`
}

//UnmarshalYAML interface implementation
func (a *StringArray) UnmarshalYAML(unmarshal func(interface{}) error) error {
	var multi []string
	err := unmarshal(&multi)
	if err != nil {
		var single string
		err := unmarshal(&single)
		if err != nil {
			return err
		}
		*a = []string{single}
	} else {
		*a = multi
	}
	return nil
}

func main() {
	t := Task{}

	err := yaml.Unmarshal([]byte(data), &t)
	if err != nil {
		log.Fatalf("error: %v", err)
	}
	fmt.Printf("--- t:\n%v\n\n", t)

	d, err := yaml.Marshal(&t)
	if err != nil {
		log.Fatalf("error: %v", err)
	}
	fmt.Printf("--- t dump:\n%s\n\n", string(d))

	m := make(map[interface{}]interface{})

	err = yaml.Unmarshal([]byte(data), &m)
	if err != nil {
		log.Fatalf("error: %v", err)
	}
	fmt.Printf("--- m:\n%v\n\n", m)

	d, err = yaml.Marshal(&m)
	if err != nil {
		log.Fatalf("error: %v", err)
	}
	fmt.Printf("--- m dump:\n%s\n\n", string(d))

	for _, s := range t.Steps {
		fmt.Printf("Value: %s\n", strings.Join(s.Cmd, ","))
	}
}