diff --git a/elections/steering/2025-GB/candidate-cblecker.md b/elections/steering/2025-GB/candidate-cblecker.md
index 9ab442829e1..bee0035d231 100644
--- a/elections/steering/2025-GB/candidate-cblecker.md
+++ b/elections/steering/2025-GB/candidate-cblecker.md
@@ -1,6 +1,9 @@
 -------------------------------------------------------------
 name: Christoph Blecker
 ID: cblecker
+info:
+  employer: Red Hat
+  slack: cblecker
 -------------------------------------------------------------
 
 # Christoph Blecker
diff --git a/elections/steering/2025-GB/candidate-cpanato.md b/elections/steering/2025-GB/candidate-cpanato.md
index a06207ba625..6210509b7ae 100644
--- a/elections/steering/2025-GB/candidate-cpanato.md
+++ b/elections/steering/2025-GB/candidate-cpanato.md
@@ -1,6 +1,9 @@
 -------------------------------------------------------------
 name: Carlos Tadeu Panato Jr
 ID: cpanato
+info:
+  employer: Chainguard
+  slack: cpanato
 -------------------------------------------------------------
 
 # Carlos Tadeu Panato Jr
diff --git a/elections/steering/2025-GB/candidate-dims.md b/elections/steering/2025-GB/candidate-dims.md
index 39d632557a3..ab31ea91ed1 100644
--- a/elections/steering/2025-GB/candidate-dims.md
+++ b/elections/steering/2025-GB/candidate-dims.md
@@ -1,6 +1,9 @@
 -------------------------------------------------------------
 name: Davanum Srinivas
 ID: dims
+info:
+  employer: Amazon Web Services
+  slack: dims
 -------------------------------------------------------------
 
 # Davanum Srinivas
diff --git a/elections/steering/2025-GB/candidate-nikhita.md b/elections/steering/2025-GB/candidate-nikhita.md
index 5a798df40ec..05619401c0b 100644
--- a/elections/steering/2025-GB/candidate-nikhita.md
+++ b/elections/steering/2025-GB/candidate-nikhita.md
@@ -1,6 +1,9 @@
 -------------------------------------------------------------
 name: Nikhita Raghunath
 ID: nikhita
+info:
+  employer: VMware
+  slack: nikhita
 -------------------------------------------------------------
 
 # Nikhita Raghunath
diff --git a/elections/steering/2025/nomination-template.md b/elections/steering/2025/nomination-template.md
index 326242271cd..75b7a3c5e8e 100644
--- a/elections/steering/2025/nomination-template.md
+++ b/elections/steering/2025/nomination-template.md
@@ -2,8 +2,8 @@
 name: 
 ID: GitHubID
 info:
-  - employer: Your Employer or "Independent"
-  - slack: slack handle
+  employer: Your Employer or "Independent"
+  slack: slack handle
 -------------------------------------------------------------
 
 <!-- Please make a copy of this template as "candidate-githubid.md" and save it to
diff --git a/hack/verify-steering-election-tool.go b/hack/verify-steering-election-tool.go
new file mode 100644
index 00000000000..ac5bdb87ab2
--- /dev/null
+++ b/hack/verify-steering-election-tool.go
@@ -0,0 +1,301 @@
+/*
+Copyright 2025 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+
+	yaml "gopkg.in/yaml.v3"
+)
+
+const (
+	maxWordCount         = 450
+	recommendedWordCount = 300
+	startYear            = 2026
+)
+
+type ValidationError struct {
+	File    string
+	Message string
+}
+
+type CandidateHeader struct {
+	Name string   `yaml:"name"`
+	ID   string   `yaml:"ID"`
+	Info InfoData `yaml:"info"`
+}
+
+type InfoData struct {
+	Employer string `yaml:"employer"`
+	Slack    string `yaml:"slack"`
+}
+
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintf(os.Stderr, "Usage: %s <elections-path>\n", os.Args[0])
+		os.Exit(1)
+	}
+
+	electionsPath := os.Args[1]
+
+	bioFiles, err := findBioFiles(electionsPath)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error finding bio files: %v\n", err)
+		os.Exit(1)
+	}
+
+	var errors []ValidationError
+
+	for _, bioFile := range bioFiles {
+		// Check word count
+		wordCount, err := countWords(bioFile)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error counting words in %s: %v\n", bioFile, err)
+			continue
+		}
+
+		if wordCount > maxWordCount {
+			errors = append(errors, ValidationError{
+				File:    bioFile,
+				Message: fmt.Sprintf("has %d words", wordCount),
+			})
+		}
+
+		// Check filename format and GitHub ID matching
+		if err := validateFileNameAndGitHubID(bioFile); err != nil {
+			errors = append(errors, ValidationError{
+				File:    bioFile,
+				Message: err.Error(),
+			})
+		}
+
+		// Check template compliance
+		if err := validateTemplateCompliance(bioFile); err != nil {
+			errors = append(errors, ValidationError{
+				File:    bioFile,
+				Message: err.Error(),
+			})
+		}
+	}
+
+	if len(errors) > 0 {
+		for _, err := range errors {
+			fmt.Printf("%s: %s\n", err.File, err.Message)
+		}
+
+		separator := strings.Repeat("=", 68)
+		fmt.Printf("\n%s\n", separator)
+		fmt.Printf("%d invalid Steering Committee election bio(s) detected.\n", len(errors))
+		fmt.Printf("Bios should be limited to around %d words, excluding headers.\n", recommendedWordCount)
+		fmt.Printf("Bios must follow the nomination template and filename format.\n")
+		fmt.Printf("%s\n", separator)
+		os.Exit(1)
+	}
+}
+
+// findBioFiles finds all steering committee candidate bio files from 2025 forward
+func findBioFiles(electionsPath string) ([]string, error) {
+	var bioFiles []string
+
+	// Walk through elections/steering directory specifically
+	steeringPath := filepath.Join(electionsPath, "steering")
+	err := filepath.Walk(steeringPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Skip if not a regular file
+		if !info.Mode().IsRegular() {
+			return nil
+		}
+
+		// Check if it's a candidate bio file
+		if !strings.HasPrefix(info.Name(), "candidate-") || !strings.HasSuffix(info.Name(), ".md") {
+			return nil
+		}
+
+		// Only include elections from startYear forward
+		pathLower := strings.ToLower(path)
+		includeFile := false
+		currentYear := time.Now().Year()
+		// Check from startYear to a few years ahead of current year
+		endYear := currentYear + 5
+		for year := startYear; year <= endYear; year++ {
+			yearStr := fmt.Sprintf("/%d/", year)
+			if strings.Contains(pathLower, yearStr) {
+				includeFile = true
+				break
+			}
+		}
+
+		if !includeFile {
+			return nil
+		}
+
+		bioFiles = append(bioFiles, path)
+		return nil
+	})
+
+	return bioFiles, err
+}
+
+// countWords counts the number of words in a file
+func countWords(filename string) (int, error) {
+	content, err := os.ReadFile(filename)
+	if err != nil {
+		return 0, err
+	}
+
+	// Split by whitespace and count non-empty strings
+	words := regexp.MustCompile(`\s+`).Split(string(content), -1)
+	count := 0
+	for _, word := range words {
+		if strings.TrimSpace(word) != "" {
+			count++
+		}
+	}
+
+	return count, nil
+}
+
+// validateFileNameAndGitHubID checks if filename matches format candidate-$username.md
+// and if the username matches the GitHub ID in the document header
+func validateFileNameAndGitHubID(filename string) error {
+	// Extract filename from path
+	base := filepath.Base(filename)
+
+	// Check filename format: candidate-*.md
+	candidateRegex := regexp.MustCompile(`^candidate-([a-zA-Z0-9_-]+)\.md$`)
+	matches := candidateRegex.FindStringSubmatch(base)
+	if len(matches) != 2 {
+		return fmt.Errorf("filename must follow format 'candidate-username.md'")
+	}
+
+	expectedUsername := matches[1]
+
+	// Read file content to extract GitHub ID
+	content, err := os.ReadFile(filename)
+	if err != nil {
+		return fmt.Errorf("error reading file: %v", err)
+	}
+
+	// Extract YAML header and parse it
+	yamlHeader, err := extractYAMLHeader(string(content))
+	if err != nil {
+		return fmt.Errorf("error extracting YAML header: %v", err)
+	}
+
+	// Parse the YAML to get the ID field
+	var header map[string]interface{}
+	if err := yaml.Unmarshal([]byte(yamlHeader), &header); err != nil {
+		return fmt.Errorf("error parsing YAML header: %v", err)
+	}
+
+	idValue, exists := header["ID"]
+	if !exists {
+		return fmt.Errorf("missing 'ID' field in header")
+	}
+
+	actualUsername, ok := idValue.(string)
+	if !ok {
+		return fmt.Errorf("'ID' field must be a string")
+	}
+
+	actualUsername = strings.TrimSpace(actualUsername)
+	if actualUsername != expectedUsername {
+		return fmt.Errorf("filename username '%s' does not match GitHub ID '%s' in header", expectedUsername, actualUsername)
+	}
+
+	return nil
+}
+
+// validateTemplateCompliance checks if the bio follows the required template structure
+func validateTemplateCompliance(filename string) error {
+	content, err := os.ReadFile(filename)
+	if err != nil {
+		return fmt.Errorf("error reading file: %v", err)
+	}
+
+	contentStr := string(content)
+
+	// Extract YAML header between dashes
+	yamlHeader, err := extractYAMLHeader(contentStr)
+	if err != nil {
+		return fmt.Errorf("error extracting YAML header: %v", err)
+	}
+
+	// Parse YAML header
+	var header CandidateHeader
+	if err := yaml.Unmarshal([]byte(yamlHeader), &header); err != nil {
+		return fmt.Errorf("invalid YAML header format: %v", err)
+	}
+
+	// Validate required fields
+	if header.Name == "" {
+		return fmt.Errorf("missing required field: name")
+	}
+	if header.ID == "" {
+		return fmt.Errorf("missing required field: ID")
+	}
+	if header.Info.Employer == "" {
+		return fmt.Errorf("missing required field: info.employer")
+	}
+	if header.Info.Slack == "" {
+		return fmt.Errorf("missing required field: info.slack")
+	}
+
+	// Check for required sections
+	requiredSections := map[string][]string{
+		"SIGs":               {"## SIGS", "## SIGs"},
+		"What I have done":   {"## What I have done"},
+		"What I'll do":       {"## What I'll do"},
+		"Resources About Me": {"## Resources About Me"},
+	}
+
+	for sectionName, alternatives := range requiredSections {
+		found := false
+		for _, section := range alternatives {
+			if strings.Contains(contentStr, section) {
+				found = true
+				break
+			}
+		}
+		if !found {
+			return fmt.Errorf("missing required section: %s", sectionName)
+		}
+	}
+
+	return nil
+}
+
+// extractYAMLHeader extracts the YAML content between dash separators
+// The format requires exactly 61 dashes for consistency
+func extractYAMLHeader(content string) (string, error) {
+	// Find the YAML header between exactly 61 dashes
+	dashRegex := regexp.MustCompile(`(?s)^-{61}\s*\n(.*?)\n-{61}\s*\n`)
+	matches := dashRegex.FindStringSubmatch(content)
+	if len(matches) != 2 {
+		return "", fmt.Errorf("could not find YAML header between dashes")
+	}
+	return matches[1], nil
+}
diff --git a/hack/verify-steering-election-tool_test.go b/hack/verify-steering-election-tool_test.go
new file mode 100644
index 00000000000..9f4a78f0b4e
--- /dev/null
+++ b/hack/verify-steering-election-tool_test.go
@@ -0,0 +1,396 @@
+/*
+Copyright 2025 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestExtractYAMLHeader(t *testing.T) {
+	tests := []struct {
+		name    string
+		content string
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "valid YAML header with exactly 61 dashes",
+			content: strings.Repeat("-", 61) + "\n" +
+				"name: Test User\n" +
+				"ID: testuser\n" +
+				"info:\n" +
+				"  employer: Test Corp\n" +
+				"  slack: '@testuser'\n" +
+				strings.Repeat("-", 61) + "\n" +
+				"## Bio content\n",
+			want:    "name: Test User\nID: testuser\ninfo:\n  employer: Test Corp\n  slack: '@testuser'",
+			wantErr: false,
+		},
+		{
+			name: "invalid YAML header with wrong number of dashes",
+			content: strings.Repeat("-", 60) + "\n" +
+				"name: Test User\n" +
+				strings.Repeat("-", 60) + "\n",
+			want:    "",
+			wantErr: true,
+		},
+		{
+			name:    "no YAML header",
+			content: "Just some content without header",
+			want:    "",
+			wantErr: true,
+		},
+		{
+			name: "YAML header with extra spaces",
+			content: strings.Repeat("-", 61) + "   \n" +
+				"name: Test User\n" +
+				"ID: testuser\n" +
+				strings.Repeat("-", 61) + "  \n" +
+				"## Bio content\n",
+			want:    "name: Test User\nID: testuser",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := extractYAMLHeader(tt.content)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("extractYAMLHeader() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("extractYAMLHeader() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestCountWords(t *testing.T) {
+	tests := []struct {
+		name    string
+		content string
+		want    int
+	}{
+		{
+			name:    "simple sentence",
+			content: "Hello world test",
+			want:    3,
+		},
+		{
+			name:    "text with newlines",
+			content: "Hello\nworld\ntest",
+			want:    3,
+		},
+		{
+			name:    "text with multiple spaces",
+			content: "Hello    world     test",
+			want:    3,
+		},
+		{
+			name:    "empty content",
+			content: "",
+			want:    0,
+		},
+		{
+			name:    "only whitespace",
+			content: "   \n\t  \n  ",
+			want:    0,
+		},
+		{
+			name:    "mixed content with punctuation",
+			content: "Hello, world! This is a test.",
+			want:    6,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a temporary file with the content
+			tmpfile, err := os.CreateTemp("", "test")
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer os.Remove(tmpfile.Name())
+
+			if _, err := tmpfile.Write([]byte(tt.content)); err != nil {
+				t.Fatal(err)
+			}
+			if err := tmpfile.Close(); err != nil {
+				t.Fatal(err)
+			}
+
+			got, err := countWords(tmpfile.Name())
+			if err != nil {
+				t.Errorf("countWords() error = %v", err)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("countWords() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestValidateFileNameAndGitHubID(t *testing.T) {
+	tests := []struct {
+		name        string
+		filename    string
+		fileContent string
+		wantErr     bool
+		errContains string
+	}{
+		{
+			name:     "valid filename and matching GitHub ID",
+			filename: "candidate-testuser.md",
+			fileContent: strings.Repeat("-", 61) + "\n" +
+				"name: Test User\n" +
+				"ID: testuser\n" +
+				"info:\n" +
+				"  employer: Test Corp\n" +
+				"  slack: '@testuser'\n" +
+				strings.Repeat("-", 61) + "\n" +
+				"## Bio content\n",
+			wantErr: false,
+		},
+		{
+			name:        "invalid filename format",
+			filename:    "invalid-format.md",
+			fileContent: "dummy content",
+			wantErr:     true,
+			errContains: "filename must follow format",
+		},
+		{
+			name:     "mismatched GitHub ID",
+			filename: "candidate-testuser.md",
+			fileContent: strings.Repeat("-", 61) + "\n" +
+				"name: Test User\n" +
+				"ID: differentuser\n" +
+				"info:\n" +
+				"  employer: Test Corp\n" +
+				"  slack: '@testuser'\n" +
+				strings.Repeat("-", 61) + "\n" +
+				"## Bio content\n",
+			wantErr:     true,
+			errContains: "does not match GitHub ID",
+		},
+		{
+			name:        "missing ID field",
+			filename:    "candidate-testuser.md",
+			fileContent: strings.Repeat("-", 61) + "\nname: Test User\n" + strings.Repeat("-", 61) + "\n",
+			wantErr:     true,
+			errContains: "missing 'ID' field",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a temporary file with the content
+			tmpfile, err := os.CreateTemp("", tt.filename)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer os.Remove(tmpfile.Name())
+
+			// Rename to the desired filename
+			dir := filepath.Dir(tmpfile.Name())
+			targetPath := filepath.Join(dir, tt.filename)
+			if err := os.Rename(tmpfile.Name(), targetPath); err != nil {
+				t.Fatal(err)
+			}
+			defer os.Remove(targetPath)
+
+			if err := os.WriteFile(targetPath, []byte(tt.fileContent), 0644); err != nil {
+				t.Fatal(err)
+			}
+
+			err = validateFileNameAndGitHubID(targetPath)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validateFileNameAndGitHubID() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if tt.wantErr && tt.errContains != "" && !strings.Contains(err.Error(), tt.errContains) {
+				t.Errorf("validateFileNameAndGitHubID() error = %v, should contain %q", err, tt.errContains)
+			}
+		})
+	}
+}
+
+func TestValidateTemplateCompliance(t *testing.T) {
+	validContent := strings.Repeat("-", 61) + "\n" +
+		"name: Test User\n" +
+		"ID: testuser\n" +
+		"info:\n" +
+		"  employer: Test Corp\n" +
+		"  slack: '@testuser'\n" +
+		strings.Repeat("-", 61) + "\n" +
+		"## What I have done\n" +
+		"Some accomplishments\n" +
+		"## What I'll do\n" +
+		"Future plans\n" +
+		"## SIGS\n" +
+		"SIG involvement\n" +
+		"## Resources About Me\n" +
+		"Links and info\n"
+
+	tests := []struct {
+		name        string
+		content     string
+		wantErr     bool
+		errContains string
+	}{
+		{
+			name:    "valid template compliance",
+			content: validContent,
+			wantErr: false,
+		},
+		{
+			name: "missing required field - name",
+			content: strings.Repeat("-", 61) + "\n" +
+				"ID: testuser\n" +
+				"info:\n" +
+				"  employer: Test Corp\n" +
+				"  slack: '@testuser'\n" +
+				strings.Repeat("-", 61) + "\n" +
+				"## What I have done\n## What I'll do\n## SIGS\n## Resources About Me\n",
+			wantErr:     true,
+			errContains: "missing required field: name",
+		},
+		{
+			name: "missing required section",
+			content: strings.Repeat("-", 61) + "\n" +
+				"name: Test User\n" +
+				"ID: testuser\n" +
+				"info:\n" +
+				"  employer: Test Corp\n" +
+				"  slack: '@testuser'\n" +
+				strings.Repeat("-", 61) + "\n" +
+				"## What I have done\n## What I'll do\n## Resources About Me\n",
+			wantErr:     true,
+			errContains: "missing required section: SIGs",
+		},
+		{
+			name: "alternative SIGs section name",
+			content: strings.Repeat("-", 61) + "\n" +
+				"name: Test User\n" +
+				"ID: testuser\n" +
+				"info:\n" +
+				"  employer: Test Corp\n" +
+				"  slack: '@testuser'\n" +
+				strings.Repeat("-", 61) + "\n" +
+				"## What I have done\n## What I'll do\n## SIGs\n## Resources About Me\n",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a temporary file with the content
+			tmpfile, err := os.CreateTemp("", "test")
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer os.Remove(tmpfile.Name())
+
+			if err := os.WriteFile(tmpfile.Name(), []byte(tt.content), 0644); err != nil {
+				t.Fatal(err)
+			}
+
+			err = validateTemplateCompliance(tmpfile.Name())
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validateTemplateCompliance() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if tt.wantErr && tt.errContains != "" && !strings.Contains(err.Error(), tt.errContains) {
+				t.Errorf("validateTemplateCompliance() error = %v, should contain %q", err, tt.errContains)
+			}
+		})
+	}
+}
+
+func TestFindBioFiles(t *testing.T) {
+	// Create a temporary directory structure
+	tmpDir, err := os.MkdirTemp("", "elections")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	// Create steering directory structure
+	steeringDir := filepath.Join(tmpDir, "steering")
+	if err := os.MkdirAll(steeringDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	// Create test files
+	currentYear := time.Now().Year()
+	testFiles := []struct {
+		path      string
+		shouldFind bool
+	}{
+		{filepath.Join(steeringDir, "2025", "candidate-user1.md"), false}, // Before startYear (2026)
+		{filepath.Join(steeringDir, "2026", "candidate-user2.md"), true},  // At startYear
+		{filepath.Join(steeringDir, fmt.Sprintf("%d", currentYear+1), "candidate-user3.md"), true}, // Future year
+		{filepath.Join(steeringDir, "2026", "not-candidate.md"), false},     // Wrong filename format
+		{filepath.Join(steeringDir, "2026", "candidate-user4.txt"), false},  // Wrong extension
+		{filepath.Join(steeringDir, fmt.Sprintf("%d", currentYear+10), "candidate-user5.md"), false}, // Too far in future
+	}
+
+	var expectedFiles []string
+	for _, tf := range testFiles {
+		dir := filepath.Dir(tf.path)
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(tf.path, []byte("dummy content"), 0644); err != nil {
+			t.Fatal(err)
+		}
+		if tf.shouldFind {
+			expectedFiles = append(expectedFiles, tf.path)
+		}
+	}
+
+	// Test findBioFiles
+	bioFiles, err := findBioFiles(tmpDir)
+	if err != nil {
+		t.Errorf("findBioFiles() error = %v", err)
+		return
+	}
+
+	if len(bioFiles) != len(expectedFiles) {
+		t.Errorf("findBioFiles() found %d files, expected %d", len(bioFiles), len(expectedFiles))
+	}
+
+	// Check that all expected files are found
+	for _, expected := range expectedFiles {
+		found := false
+		for _, actual := range bioFiles {
+			if actual == expected {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("findBioFiles() did not find expected file: %s", expected)
+		}
+	}
+}
\ No newline at end of file
diff --git a/hack/verify-steering-election.sh b/hack/verify-steering-election.sh
index 6034b8d595f..89549978a19 100755
--- a/hack/verify-steering-election.sh
+++ b/hack/verify-steering-election.sh
@@ -17,30 +17,7 @@
 set -o errexit
 set -o nounset
 set -o pipefail
-shopt -s extglob
 
-export KUBE_ROOT=$(dirname "${BASH_SOURCE}")/..
-
-# exclude bios before 2025 since some of them have more than 300 words
-STEERING_ELECTION_BIOS="${KUBE_ROOT}/elections/steering/!(2017|2018|2019|2020|2021|2022|2023|2024)/candidate-*.md"
-
-invalid_bios=0
-break=$(printf "=%.0s" $(seq 1 68))
-
-for bio in ${STEERING_ELECTION_BIOS} ; do
-  [[ -f $bio ]] || continue
-  word_count=$(wc -w < "$bio")
-  if [[ ${word_count} -gt "450" ]]; then
-    echo "${bio} has ${word_count} words."
-    invalid_bios=$((invalid_bios+1))
-  fi
-done
-
-if [[ ${invalid_bios} -gt "0" ]]; then
-  echo ""
-  echo "${break}"
-  echo "${invalid_bios} invalid Steering Committee election bio(s) detected."
-  echo "Bios should be limited to around 300 words, excluding headers."
-  echo "${break}"
-  exit 1;
-fi
+# Build and run the Go utility
+cd "$(dirname "${BASH_SOURCE[0]}")/.."
+go run hack/verify-steering-election-tool.go elections