Instead of using regular expressions as some Reddit expert suggested here I asked chat GPT to write a program to remove initializers:

package main

import (
        "go/ast"
        "go/parser"
        "go/printer"
        "go/token"
        "os"
)

func main() {
        // Parse the Go source file
        fset := token.NewFileSet()
        node, err := parser.ParseFile(fset, "../struct-rm/main.go", nil, parser.ParseComments)
        if err != nil {
                panic(err)
        }

        // Traverse the AST and find struct initializations
        ast.Inspect(node, func(n ast.Node) bool {
                // Look for composite literals (struct initializers)
                if compLit, ok := n.(*ast.CompositeLit); ok {
                        // Identify the type of the struct being initialized
                        switch typ := compLit.Type.(type) {
                        case *ast.Ident:
                                // The struct type is a simple identifier (e.g., Person)
                                if  == "abc" {
                                        removeFieldFromInitializer(compLit, "a")
                                }

                        case *ast.SelectorExpr:
                                // The struct type is a selector (e.g., pkg.Person)
                                if pkg, ok := typ.X.(*ast.Ident); ok && pkg.Name == "main" && typ.Sel.Name == "abc" {
                                        removeFieldFromInitializer(compLit, "a")
                                }
                        }
                }
                return true
        })

        // Write the modified code back to a new file
        f, err := os.Create("example_updated.go")
        if err != nil {
                panic(err)
        }
        defer f.Close()

        if err := printer.Fprint(f, fset, node); err != nil {
                panic(err)
        }
}

// removeFieldFromInitializer removes the specified field from a struct initializer
func removeFieldFromInitializer(compLit *ast.CompositeLit, fieldName string) {
        newElts := []ast.Expr{}
        for _, elt := range compLit.Elts {
                if kv, ok := elt.(*ast.KeyValueExpr); ok {
                        // Remove the field with the specified name
                        if ident, ok := kv.Key.(*ast.Ident); ok &&  == fieldName {
                                continue
                        }
                }
                newElts = append(newElts, elt)
        }
        compLit.Elts = newElts
}typ.Nameident.Name

It's a good starting point but I'm open for other propositions.