diff --git a/docs/book/src/SUMMARY.md b/docs/book/src/SUMMARY.md
index aa4d36bd6f1..a53bc5324ca 100644
--- a/docs/book/src/SUMMARY.md
+++ b/docs/book/src/SUMMARY.md
@@ -95,6 +95,7 @@
     - [Object/DeepCopy](./reference/markers/object.md)
     - [RBAC](./reference/markers/rbac.md)
     - [Scaffold](./reference/markers/scaffold.md)
+    - [Feature Gates](./reference/markers/feature-gates.md)
 
   - [controller-gen CLI](./reference/controller-gen.md)
   - [completion](./reference/completion.md)
diff --git a/docs/book/src/quick-start.md b/docs/book/src/quick-start.md
index bdedbf7377c..58672f8c5f1 100644
--- a/docs/book/src/quick-start.md
+++ b/docs/book/src/quick-start.md
@@ -74,6 +74,23 @@ Run the following command to create a new API (group/version) as `webapp/v1` and
 kubebuilder create api --group webapp --version v1 --kind Guestbook
 ```
 
+<aside class="note">
+<h1>Feature Gates (Optional)</h1>
+
+If you plan to use experimental features with feature gates, you can include the infrastructure during project creation:
+
+```bash
+# Initialize project with feature gate support
+kubebuilder init --domain my.domain --repo my.domain/guestbook --with-feature-gates
+
+# Or add feature gate support when creating APIs
+kubebuilder create api --group webapp --version v1 --kind Guestbook --with-feature-gates
+```
+
+Feature gate infrastructure is only generated when explicitly requested or when `+feature-gate` markers are detected in your API types. See the [Feature Gates reference](/reference/markers/feature-gates.md) for more details.
+
+</aside>
+
 <aside class="note">
 <h1>Press Options</h1>
 
diff --git a/docs/book/src/reference/markers.md b/docs/book/src/reference/markers.md
index 0520717b0f2..37f5637363a 100644
--- a/docs/book/src/reference/markers.md
+++ b/docs/book/src/reference/markers.md
@@ -38,8 +38,8 @@ controller-gen:
 
 - `make manifests` generates Kubernetes object YAML, like
   [CustomResourceDefinitions](./markers/crd.md),
-  [WebhookConfigurations](./markers/webhook.md), and [RBAC
-  roles](./markers/rbac.md).
+  [WebhookConfigurations](./markers/webhook.md), [RBAC
+  roles](./markers/rbac.md), and [Feature Gates](./markers/feature-gates.md).
 
 - `make generate` generates code, like [runtime.Object/DeepCopy
   implementations](./markers/object.md).
diff --git a/docs/book/src/reference/markers/feature-gates.md b/docs/book/src/reference/markers/feature-gates.md
new file mode 100644
index 00000000000..2a5687cd86f
--- /dev/null
+++ b/docs/book/src/reference/markers/feature-gates.md
@@ -0,0 +1,406 @@
+# Feature Gates
+
+Feature gates allow you to enable or disable experimental features in your Kubebuilder controllers. This is similar to how Kubernetes core uses feature gates to manage experimental functionality.
+
+> **Note**: Feature gate infrastructure is **optional** and only generated when explicitly requested or detected. This provides a better user experience by avoiding unnecessary scaffolding.
+
+## Quick Start
+
+### Enabling Feature Gate Infrastructure
+
+Feature gate infrastructure can be enabled in two ways:
+
+1. **During project initialization** with the `--with-feature-gates` flag:
+   ```bash
+   kubebuilder init --domain my.domain --repo my.domain/project --with-feature-gates
+   ```
+
+2. **During API creation** when adding experimental fields:
+   ```bash
+   kubebuilder create api --group webapp --version v1 --kind Guestbook --with-feature-gates
+   ```
+
+3. **Auto-detection**: If you add `+feature-gate` markers to your API types and run `kubebuilder create api`, the infrastructure will be automatically generated.
+
+### Marking Fields
+
+```go
+type MyResourceSpec struct {
+    // Standard field
+    Name string `json:"name"`
+
+    // Experimental field
+    // +feature-gate experimental-bar
+    // +optional
+    Bar *string `json:"bar,omitempty"`
+}
+```
+
+### Running with Feature Gates
+
+```bash
+# Enable feature gates
+./manager --feature-gates=experimental-bar=true
+
+# Multiple gates
+./manager --feature-gates=experimental-bar=true,advanced-features=false
+
+# All gates enabled (useful for testing)
+./manager --feature-gates=experimental-bar=true,advanced-features=true
+```
+
+## Overview
+
+Feature gates provide a mechanism to:
+- Control the availability of experimental features
+- Enable gradual rollout of new functionality
+- Maintain backward compatibility during API evolution
+- Test experimental functionality safely in production environments
+
+**Infrastructure Generation**: Feature gate infrastructure is only generated when:
+- The `--with-feature-gates` flag is used with `kubebuilder init` or `kubebuilder create api`
+- Auto-detected when existing feature gate infrastructure is found in the project
+- Auto-detected when `+feature-gate` markers are found in API types during `kubebuilder create api`
+
+This optional approach ensures projects only include feature gate infrastructure when actually needed.
+
+## Usage
+
+### Marking Fields with Feature Gates
+
+Use the `+feature-gate` marker to mark experimental fields in your API types:
+
+```go
+type MyResourceSpec struct {
+    // Standard field - always available
+    Name string `json:"name"`
+
+    // Experimental field that requires the "experimental-bar" feature gate
+    // +feature-gate experimental-bar
+    // +optional
+    Bar *string `json:"bar,omitempty"`
+
+    // Another experimental field with different gate
+    // +feature-gate advanced-features
+    // This field enables advanced processing capabilities
+    // +optional
+    AdvancedConfig *AdvancedConfig `json:"advancedConfig,omitempty"`
+}
+```
+
+### Feature Gate Validation
+
+Feature gates are validated for proper format:
+- **Valid**: `experimental-bar=true,advanced-features=false`
+- **Valid**: `experimental-bar=true` (short form)
+- **Invalid**: `experimental-bar=maybe` (only 'true' and 'false' are allowed)
+- **Invalid**: `ExperimentalBar=true` (should use kebab-case)
+
+### Automated Discovery
+
+Kubebuilder automatically discovers feature gates from your API types during scaffolding:
+
+1. **During `kubebuilder init --with-feature-gates`**: Generates infrastructure for future use
+2. **During `kubebuilder create api --with-feature-gates`**: Generates infrastructure and scans for markers
+3. **During `kubebuilder create api`**: Auto-detects existing infrastructure or discovers new `+feature-gate` markers
+4. **Generates `internal/featuregates/featuregates.go`**: Contains all discovered gates
+5. **Updates `cmd/main.go`**: Adds `--feature-gates` flag support
+
+**Important**: If no `--with-feature-gates` flag is provided and no feature gate infrastructure exists, it will only be generated if `+feature-gate` markers are found in your API types.
+
+```go
+// Generated in internal/featuregates/featuregates.go
+var availableFeatureGates = map[string]bool{
+    "experimental-bar":   false, // Default disabled
+    "advanced-features": false, // Default disabled
+}
+```
+
+### Controller Integration
+
+Access feature gate state in your controller logic:
+
+```go
+func (r *MyResourceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
+    log := log.FromContext(ctx)
+
+    // Get your resource
+    var myResource myapiv1.MyResource
+    if err := r.Get(ctx, req.NamespacedName, &myResource); err != nil {
+        return ctrl.Result{}, client.IgnoreNotFound(err)
+    }
+
+    // Check if experimental feature is enabled
+    if featureGates.IsEnabled("experimental-bar") && myResource.Spec.Bar != nil {
+        log.Info("Using experimental bar feature", "value", *myResource.Spec.Bar)
+        // Implement experimental functionality
+        return r.handleExperimentalBar(ctx, &myResource)
+    }
+
+    // Standard reconciliation logic
+    return r.handleStandard(ctx, &myResource)
+}
+```
+
+## Best Practices
+
+### Naming Conventions
+
+Use descriptive, lowercase names with hyphens:
+- ✅ `experimental-bar`
+- ✅ `advanced-features`
+- ✅ `timezone-support`
+- ❌ `ExperimentalBar` (should be kebab-case)
+- ❌ `advanced_features` (use hyphens, not underscores)
+
+### Documentation
+
+Always document feature-gated fields:
+
+```go
+// Bar is an experimental field that provides enhanced functionality.
+// It requires the "experimental-bar" feature gate to be enabled.
+// When disabled, this field is ignored during reconciliation.
+// +feature-gate experimental-bar
+// +optional
+Bar *string `json:"bar,omitempty"`
+```
+
+### Gradual Rollout Strategy
+
+1. **Alpha**: Feature behind feature gate (disabled by default)
+   ```go
+   // +feature-gate experimental-feature
+   ExperimentalField *string `json:"experimentalField,omitempty"`
+   ```
+
+2. **Beta**: Feature available but can be disabled
+   ```go
+   // +feature-gate beta-feature
+   BetaField *string `json:"betaField,omitempty"`
+   ```
+
+3. **Stable**: Remove feature gate, feature always available
+   ```go
+   // No feature gate marker - always available
+   StableField string `json:"stableField"`
+   ```
+
+### Testing
+
+Test your controller with different feature gate configurations:
+
+```bash
+# Test with all features disabled (default)
+make test
+
+# Test with specific features enabled
+FEATURE_GATES="experimental-bar=true" make test
+
+# Test with all features enabled
+FEATURE_GATES="experimental-bar=true,advanced-features=true" make test
+```
+
+## Deployment Configurations
+
+### Development Environment
+
+```yaml
+# config/manager/manager.yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: controller-manager
+spec:
+  template:
+    spec:
+      containers:
+      - name: manager
+        args:
+        - --leader-elect
+        - --feature-gates=experimental-bar=true,advanced-features=true
+```
+
+### Production Environment
+
+```yaml
+# Production - only stable features
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: controller-manager
+spec:
+  template:
+    spec:
+      containers:
+      - name: manager
+        args:
+        - --leader-elect
+        - --feature-gates=experimental-bar=false,advanced-features=false
+```
+
+### Canary Deployment
+
+```yaml
+# Canary deployment with experimental features
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: controller-manager-canary
+spec:
+  replicas: 1
+  template:
+    spec:
+      containers:
+      - name: manager
+        args:
+        - --leader-elect
+        - --feature-gates=experimental-bar=true
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Feature gate infrastructure not generated**
+   - Use `--with-feature-gates` flag explicitly: `kubebuilder init --with-feature-gates` or `kubebuilder create api --with-feature-gates`
+   - Add `+feature-gate` markers to your API types and run `kubebuilder create api` (auto-detection)
+   - Ensure you're in a project directory with existing feature gate infrastructure
+
+2. **Feature gate not discovered**
+   - Ensure the `+feature-gate` marker is on the line immediately before the field
+   - Re-run `kubebuilder create api --with-feature-gates` to regenerate feature gate files
+   - Check that the marker follows the correct format: `// +feature-gate gate-name`
+
+3. **Invalid feature gate name**
+   - Use only lowercase letters, numbers, and hyphens
+   - Examples: `experimental-bar`, `alpha-feature-v2`
+
+4. **Validation errors**
+   - Check that all specified gates are discovered in your API types
+   - Verify syntax: `gate1=true,gate2=false` (no spaces around `=`)
+
+5. **Controller not recognizing feature gates**
+   - Ensure `cmd/main.go` includes the generated feature gate initialization
+   - Verify that `internal/featuregates/featuregates.go` is properly generated
+
+### Debugging
+
+Enable debug logging to see feature gate discovery and validation:
+
+```bash
+# See feature gate initialization
+./manager --feature-gates=experimental-bar=true --zap-log-level=debug
+
+# Check available gates
+./manager --help | grep feature-gates
+```
+
+### Verification
+
+Verify your feature gates are working:
+
+```bash
+# List all available feature gates
+grep -r "+feature-gate" api/
+
+# Check generated feature gate file
+cat internal/featuregates/featuregates.go
+
+# Verify controller initialization
+grep -A 5 -B 5 "feature-gates" cmd/main.go
+```
+
+## Implementation Status
+
+### ✅ Production Ready
+
+- Feature gate discovery from API type markers
+- CLI flag `--feature-gates` for runtime control
+- Automatic scaffolding integration
+- Validation and error handling
+- Controller runtime integration
+
+### 🚧 Future Enhancement
+
+- **CRD schema modification**: Requires [controller-tools support](https://github.com/kubernetes-sigs/controller-tools/issues/1238)
+- **Helm chart integration**: Dynamic feature gate configuration in Helm values
+- **Operator lifecycle management**: Feature gate coordination across multiple controllers
+
+When controller-tools gains feature gate support, you'll be able to use:
+
+```go
+// +kubebuilder:feature-gate=experimental-bar
+// +optional
+Bar *string `json:"bar,omitempty"`
+```
+
+This will automatically exclude the field from CRD schemas when the feature gate is disabled, providing true schema-level gating.
+
+## Examples
+
+### Complete Working Example
+
+Here's a complete example showing feature gates in action:
+
+```go
+// api/v1/webapp_types.go
+type WebAppSpec struct {
+    // Core functionality - always available
+    Image    string `json:"image"`
+    Replicas int32  `json:"replicas"`
+
+    // Experimental auto-scaling
+    // +feature-gate auto-scaling
+    // +optional
+    AutoScaling *AutoScalingConfig `json:"autoScaling,omitempty"`
+
+    // Beta feature - advanced routing
+    // +feature-gate advanced-routing
+    // +optional
+    AdvancedRouting *RoutingConfig `json:"advancedRouting,omitempty"`
+}
+
+type AutoScalingConfig struct {
+    MinReplicas int32 `json:"minReplicas"`
+    MaxReplicas int32 `json:"maxReplicas"`
+    TargetCPU   int32 `json:"targetCPU"`
+}
+
+type RoutingConfig struct {
+    Rules []RoutingRule `json:"rules"`
+}
+```
+
+```go
+// controllers/webapp_controller.go
+func (r *WebAppReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
+    log := log.FromContext(ctx)
+
+    var webapp webappv1.WebApp
+    if err := r.Get(ctx, req.NamespacedName, &webapp); err != nil {
+        return ctrl.Result{}, client.IgnoreNotFound(err)
+    }
+
+    // Handle auto-scaling if enabled
+    if featureGates.IsEnabled("auto-scaling") && webapp.Spec.AutoScaling != nil {
+        log.Info("Configuring auto-scaling", "min", webapp.Spec.AutoScaling.MinReplicas)
+        if err := r.reconcileAutoScaling(ctx, &webapp); err != nil {
+            return ctrl.Result{}, err
+        }
+    }
+
+    // Handle advanced routing if enabled
+    if featureGates.IsEnabled("advanced-routing") && webapp.Spec.AdvancedRouting != nil {
+        log.Info("Configuring advanced routing")
+        if err := r.reconcileAdvancedRouting(ctx, &webapp); err != nil {
+            return ctrl.Result{}, err
+        }
+    }
+
+    // Core reconciliation logic
+    return r.reconcileCore(ctx, &webapp)
+}
+```
+
+This example demonstrates how feature gates enable experimental functionality while maintaining backward compatibility.
\ No newline at end of file
diff --git a/go.mod b/go.mod
index 18274ccc4f4..c084ddf165e 100644
--- a/go.mod
+++ b/go.mod
@@ -10,6 +10,7 @@ require (
 	github.com/spf13/afero v1.14.0
 	github.com/spf13/cobra v1.9.1
 	github.com/spf13/pflag v1.0.7
+	github.com/stretchr/testify v1.10.0
 	golang.org/x/mod v0.27.0
 	golang.org/x/text v0.28.0
 	golang.org/x/tools v0.36.0
@@ -19,6 +20,7 @@ require (
 
 require (
 	github.com/Masterminds/semver/v3 v3.3.0 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/go-logr/logr v1.4.2 // indirect
 	github.com/go-task/slim-sprig/v3 v3.0.0 // indirect
 	github.com/google/go-cmp v0.7.0 // indirect
@@ -27,6 +29,7 @@ require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/rogpeppe/go-internal v1.14.1 // indirect
 	go.uber.org/automaxprocs v1.6.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.2 // indirect
diff --git a/hack/docs/internal/cronjob-tutorial/generate_cronjob.go b/hack/docs/internal/cronjob-tutorial/generate_cronjob.go
index 4e5023f3de0..de2726cb0ca 100644
--- a/hack/docs/internal/cronjob-tutorial/generate_cronjob.go
+++ b/hack/docs/internal/cronjob-tutorial/generate_cronjob.go
@@ -226,12 +226,28 @@ type CronJob struct {`+`
 	 */`)
 	hackutils.CheckError("fixing schema for cronjob_types.go", err)
 
-	// fix lint
+	// fix lint - handle the pattern with or without feature-gated fields
 	err = pluginutil.ReplaceInFile(
 		filepath.Join(sp.ctx.Dir, "api/v1/cronjob_types.go"),
 		`/
 	
+
+	// Example of a feature-gated field:
+	// Bar is an experimental field that requires the "experimental-bar" feature gate to be enabled
+	// TODO: When controller-tools supports feature gates (issue #1238), use:
+	// +kubebuilder:feature-gate=experimental-bar
+	// +feature-gate experimental-bar
+	// +optional
+	Bar *string `+"`"+`json:"bar,omitempty"`+"`"+`
+}`, "/")
+	if err != nil {
+		// Fallback to the original pattern if the feature-gated field is not present
+		err = pluginutil.ReplaceInFile(
+			filepath.Join(sp.ctx.Dir, "api/v1/cronjob_types.go"),
+			`/
+	
 }`, "/")
+	}
 	hackutils.CheckError("fixing cronjob_types.go end of status", err)
 }
 
diff --git a/hack/docs/internal/multiversion-tutorial/generate_multiversion.go b/hack/docs/internal/multiversion-tutorial/generate_multiversion.go
index 29e5e5f710f..d506b7deac0 100644
--- a/hack/docs/internal/multiversion-tutorial/generate_multiversion.go
+++ b/hack/docs/internal/multiversion-tutorial/generate_multiversion.go
@@ -735,11 +735,25 @@ We'll leave our spec largely unchanged, except to change the schedule field to a
 
 	err = pluginutil.ReplaceInFile(
 		filepath.Join(sp.ctx.Dir, path),
-		`// foo is an example field of CronJob. Edit cronjob_types.go to remove/update
+		`// Example of a feature-gated field:
+	// Bar is an experimental field that requires the "experimental-bar" feature gate to be enabled
+	// TODO: When controller-tools supports feature gates (issue #1238), use:
+	// +kubebuilder:feature-gate=experimental-bar
+	// +feature-gate experimental-bar
 	// +optional
-	Foo *string `+"`json:\"foo,omitempty\"`",
+	Bar *string `+"`"+`json:"bar,omitempty"`+"`",
 		cronjobSpecMore,
 	)
+	if err != nil {
+		// Fallback to the original pattern if the feature-gated field is not present
+		err = pluginutil.ReplaceInFile(
+			filepath.Join(sp.ctx.Dir, path),
+			`// foo is an example field of CronJob. Edit cronjob_types.go to remove/update
+	// +optional
+	Foo *string `+"`json:\"foo,omitempty\"`",
+			cronjobSpecMore,
+		)
+	}
 	hackutils.CheckError("replace Foo with cronjob spec fields", err)
 
 	err = pluginutil.ReplaceInFile(
diff --git a/pkg/machinery/featuregate.go b/pkg/machinery/featuregate.go
new file mode 100644
index 00000000000..14f16ae7add
--- /dev/null
+++ b/pkg/machinery/featuregate.go
@@ -0,0 +1,161 @@
+/*
+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 machinery
+
+import (
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+// featureGateNameRegex validates feature gate names
+// Names should follow Kubernetes conventions: start with lowercase letter, followed by lowercase alphanumeric with hyphens
+var featureGateNameRegex = regexp.MustCompile(`^[a-z][a-z0-9]*(-[a-z0-9]+)*$`)
+
+// FeatureGate represents a feature gate with its name and enabled state
+type FeatureGate struct {
+	Name    string
+	Enabled bool
+}
+
+// FeatureGates represents a collection of feature gates
+type FeatureGates map[string]bool
+
+// validateFeatureGateName validates that a feature gate name follows conventions
+func validateFeatureGateName(name string) error {
+	if name == "" {
+		return fmt.Errorf("empty feature gate name")
+	}
+
+	if !featureGateNameRegex.MatchString(name) {
+		return fmt.Errorf("invalid feature gate name '%s': must be lowercase alphanumeric with hyphens (e.g., 'experimental-feature')", name)
+	}
+
+	return nil
+}
+
+// ParseFeatureGates parses a comma-separated string of feature gates
+// Format: "feature1=true,feature2=false,feature3=true"
+// Feature gate names must be lowercase alphanumeric with hyphens
+// Values must be 'true' or 'false' (case insensitive)
+func ParseFeatureGates(featureGates string) (FeatureGates, error) {
+	if featureGates == "" {
+		return make(FeatureGates), nil
+	}
+
+	gates := make(FeatureGates)
+	parts := strings.Split(featureGates, ",")
+
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			return nil, fmt.Errorf("empty feature gate name in input")
+		}
+
+		// Parse the feature gate name and value
+		var name string
+		var enabled bool = true // Default to enabled
+
+		if strings.Contains(part, "=") {
+			kv := strings.SplitN(part, "=", 2)
+			if len(kv) != 2 {
+				return nil, fmt.Errorf("invalid feature gate format: %s", part)
+			}
+			name = strings.TrimSpace(kv[0])
+			value := strings.TrimSpace(kv[1])
+
+			if value == "" {
+				return nil, fmt.Errorf("empty value for feature gate '%s'", name)
+			}
+
+			switch strings.ToLower(value) {
+			case "true":
+				enabled = true
+			case "false":
+				enabled = false
+			default:
+				return nil, fmt.Errorf("invalid feature gate value for %s: %s (must be 'true' or 'false')", name, value)
+			}
+		} else {
+			// No '=' found, treat entire part as name with default value true
+			name = part
+		}
+
+		// Validate the feature gate name
+		if err := validateFeatureGateName(name); err != nil {
+			return nil, err
+		}
+
+		gates[name] = enabled
+	}
+
+	return gates, nil
+}
+
+// IsEnabled checks if a specific feature gate is enabled
+func (fg FeatureGates) IsEnabled(name string) bool {
+	enabled, exists := fg[name]
+	return exists && enabled
+}
+
+// GetEnabledGates returns a list of enabled feature gate names
+func (fg FeatureGates) GetEnabledGates() []string {
+	var enabled []string
+	for name, isEnabled := range fg {
+		if isEnabled {
+			enabled = append(enabled, name)
+		}
+	}
+	return enabled
+}
+
+// GetDisabledGates returns a list of disabled feature gate names
+func (fg FeatureGates) GetDisabledGates() []string {
+	var disabled []string
+	for name, enabled := range fg {
+		if !enabled {
+			disabled = append(disabled, name)
+		}
+	}
+	return disabled
+}
+
+// String returns a string representation of the feature gates
+func (fg FeatureGates) String() string {
+	if len(fg) == 0 {
+		return ""
+	}
+
+	// Get feature gate names and sort them for consistent output
+	names := make([]string, 0, len(fg))
+	for name := range fg {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	var parts []string
+	for _, name := range names {
+		enabled := fg[name]
+		if enabled {
+			parts = append(parts, name)
+		} else {
+			parts = append(parts, fmt.Sprintf("%s=false", name))
+		}
+	}
+	return strings.Join(parts, ",")
+}
diff --git a/pkg/machinery/featuregate_marker.go b/pkg/machinery/featuregate_marker.go
new file mode 100644
index 00000000000..1c8cdba2122
--- /dev/null
+++ b/pkg/machinery/featuregate_marker.go
@@ -0,0 +1,239 @@
+/*
+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 machinery
+
+import (
+	"bufio"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"regexp"
+	"strings"
+)
+
+// FeatureGateMarker represents a feature gate marker found in source code
+type FeatureGateMarker struct {
+	GateName string
+	Line     int
+	File     string
+}
+
+// FeatureGateMarkerParser parses Go source files for feature gate markers
+type FeatureGateMarkerParser struct {
+	// Regex to match feature gate markers
+	// Matches: // +feature-gate gate-name
+	markerRegex *regexp.Regexp
+}
+
+// NewFeatureGateMarkerParser creates a new feature gate marker parser
+func NewFeatureGateMarkerParser() *FeatureGateMarkerParser {
+	return &FeatureGateMarkerParser{
+		markerRegex: regexp.MustCompile(`^\s*//\s*\+feature-gate\s+([a-zA-Z0-9_-]+)\s*$`),
+	}
+}
+
+// ParseFile parses a Go source file for feature gate markers
+func (p *FeatureGateMarkerParser) ParseFile(filePath string) ([]FeatureGateMarker, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file %s: %w", filePath, err)
+	}
+	defer file.Close()
+
+	var markers []FeatureGateMarker
+	scanner := bufio.NewScanner(file)
+	lineNum := 0
+	var lines []string
+
+	// First pass: collect all lines
+	for scanner.Scan() {
+		lines = append(lines, scanner.Text())
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("error reading file %s: %w", filePath, err)
+	}
+
+	// Second pass: analyze lines to find feature gate markers associated with real code
+	for i, line := range lines {
+		lineNum = i + 1
+
+		matches := p.markerRegex.FindStringSubmatch(line)
+		if len(matches) == 2 {
+			// Check if this marker is associated with actual code (not just comments)
+			if p.isMarkerAssociatedWithCode(lines, i) {
+				markers = append(markers, FeatureGateMarker{
+					GateName: matches[1],
+					Line:     lineNum,
+					File:     filePath,
+				})
+			}
+		}
+	}
+
+	return markers, nil
+}
+
+// isMarkerAssociatedWithCode checks if a feature gate marker is associated with actual code
+// rather than just commented code
+func (p *FeatureGateMarkerParser) isMarkerAssociatedWithCode(lines []string, markerLineIndex int) bool {
+	// Look ahead for actual code (not comments) within the next few lines
+	// Feature gate markers should be followed by actual field declarations
+	for i := markerLineIndex + 1; i < len(lines) && i <= markerLineIndex+5; i++ {
+		line := lines[i]
+		trimmed := strings.TrimSpace(line)
+
+		// Skip empty lines
+		if trimmed == "" {
+			continue
+		}
+
+		// If we hit another marker, stop looking
+		if strings.Contains(trimmed, "+feature-gate") {
+			break
+		}
+
+		// If we hit end of struct, stop looking
+		if strings.Contains(trimmed, "}") {
+			break
+		}
+
+		// Skip pure comment lines
+		if strings.HasPrefix(trimmed, "//") {
+			continue
+		}
+
+		// Check if this line contains actual Go code (field declaration, struct, etc.)
+		// Look for patterns like: FieldName Type `json:"fieldName,omitempty"`
+		if strings.Contains(trimmed, "`json:") ||
+			strings.Contains(trimmed, "string") ||
+			strings.Contains(trimmed, "int") ||
+			strings.Contains(trimmed, "bool") ||
+			strings.Contains(trimmed, "*") {
+			return true
+		}
+	}
+
+	return false
+}
+
+// ParseDirectory parses all Go files in a directory for feature gate markers
+func (p *FeatureGateMarkerParser) ParseDirectory(dirPath string) ([]FeatureGateMarker, error) {
+	fset := token.NewFileSet()
+	pkgs, err := parser.ParseDir(fset, dirPath, nil, parser.ParseComments)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse directory %s: %w", dirPath, err)
+	}
+
+	var allMarkers []FeatureGateMarker
+
+	for _, pkg := range pkgs {
+		for fileName, file := range pkg.Files {
+			markers := p.parseASTFile(fileName, file, fset)
+			allMarkers = append(allMarkers, markers...)
+		}
+	}
+
+	return allMarkers, nil
+}
+
+// parseASTFile parses an AST file for feature gate markers
+func (p *FeatureGateMarkerParser) parseASTFile(fileName string, file *ast.File, fset *token.FileSet) []FeatureGateMarker {
+	var markers []FeatureGateMarker
+
+	// Parse comments for feature gate markers
+	for _, commentGroup := range file.Comments {
+		for _, comment := range commentGroup.List {
+			matches := p.markerRegex.FindStringSubmatch(comment.Text)
+			if len(matches) == 2 {
+				// Check if this marker is associated with actual code (not just comments)
+				if p.isASTMarkerAssociatedWithCode(file, fset, comment) {
+					markers = append(markers, FeatureGateMarker{
+						GateName: matches[1],
+						Line:     fset.Position(comment.Pos()).Line,
+						File:     fileName,
+					})
+				}
+			}
+		}
+	}
+
+	return markers
+}
+
+// isASTMarkerAssociatedWithCode checks if a feature gate marker in AST is associated with actual code
+// rather than just commented code
+func (p *FeatureGateMarkerParser) isASTMarkerAssociatedWithCode(file *ast.File, fset *token.FileSet, comment *ast.Comment) bool {
+	commentPos := fset.Position(comment.Pos())
+
+	// Look for AST nodes that come after this comment
+	for _, decl := range file.Decls {
+		declPos := fset.Position(decl.Pos())
+
+		// Look for field declarations within structs
+		if genDecl, ok := decl.(*ast.GenDecl); ok {
+			for _, spec := range genDecl.Specs {
+				if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+					if structType, ok := typeSpec.Type.(*ast.StructType); ok {
+						for _, field := range structType.Fields.List {
+							fieldPos := fset.Position(field.Pos())
+							// Check if this field is within a reasonable distance from the comment (before or after)
+							if fieldPos.Line >= commentPos.Line-2 && fieldPos.Line <= commentPos.Line+5 {
+								// This field is close to the comment, so the marker is likely associated with it
+								return true
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// If we've looked too far ahead, stop
+		if declPos.Line > commentPos.Line+10 {
+			break
+		}
+	}
+
+	return false
+}
+
+// ExtractFeatureGates extracts all unique feature gate names from markers
+func ExtractFeatureGates(markers []FeatureGateMarker) []string {
+	gateMap := make(map[string]bool)
+	for _, marker := range markers {
+		gateMap[marker.GateName] = true
+	}
+
+	var gates []string
+	for gate := range gateMap {
+		gates = append(gates, gate)
+	}
+	return gates
+}
+
+// ValidateFeatureGates validates that all required feature gates are enabled
+func ValidateFeatureGates(requiredGates []string, enabledGates FeatureGates) []string {
+	var missing []string
+	for _, gate := range requiredGates {
+		if !enabledGates.IsEnabled(gate) {
+			missing = append(missing, gate)
+		}
+	}
+	return missing
+}
diff --git a/pkg/machinery/featuregate_marker_test.go b/pkg/machinery/featuregate_marker_test.go
new file mode 100644
index 00000000000..4903c16398b
--- /dev/null
+++ b/pkg/machinery/featuregate_marker_test.go
@@ -0,0 +1,210 @@
+/*
+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 machinery
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFeatureGateMarkerParser_ParseFile(t *testing.T) {
+	parser := NewFeatureGateMarkerParser()
+
+	// Create a temporary test file
+	tempDir := t.TempDir()
+	testFile := filepath.Join(tempDir, "test.go")
+
+	content := `package test
+
+import "fmt"
+
+// MyStruct represents a test struct
+type MyStruct struct {
+	// Regular field
+	Name string ` + "`" + `json:"name"` + "`" + `
+
+	// Feature gated field
+	// +feature-gate experimental-feature
+	ExperimentalField string ` + "`" + `json:"experimentalField,omitempty"` + "`" + `
+
+	// Another feature gated field
+	// +feature-gate another-feature
+	AnotherField int ` + "`" + `json:"anotherField,omitempty"` + "`" + `
+
+	// Regular comment
+	// This is not a feature gate marker
+	RegularField bool ` + "`" + `json:"regularField"` + "`" + `
+}
+
+// +feature-gate function-feature
+func (m *MyStruct) ExperimentalMethod() {
+	fmt.Println("This is experimental")
+}
+`
+
+	err := os.WriteFile(testFile, []byte(content), 0644)
+	assert.NoError(t, err)
+
+	markers, err := parser.ParseFile(testFile)
+	assert.NoError(t, err)
+	assert.Len(t, markers, 3)
+
+	// Check that we found the expected feature gates
+	expectedGates := map[string]bool{
+		"experimental-feature": false,
+		"another-feature":      false,
+		"function-feature":     false,
+	}
+
+	for _, marker := range markers {
+		assert.Contains(t, expectedGates, marker.GateName)
+		assert.Equal(t, testFile, marker.File)
+		assert.Greater(t, marker.Line, 0)
+	}
+}
+
+func TestExtractFeatureGates(t *testing.T) {
+	markers := []FeatureGateMarker{
+		{GateName: "feature1", Line: 1, File: "test1.go"},
+		{GateName: "feature2", Line: 2, File: "test1.go"},
+		{GateName: "feature1", Line: 3, File: "test2.go"}, // Duplicate
+		{GateName: "feature3", Line: 4, File: "test2.go"},
+	}
+
+	gates := ExtractFeatureGates(markers)
+	assert.ElementsMatch(t, []string{"feature1", "feature2", "feature3"}, gates)
+}
+
+func TestValidateFeatureGates(t *testing.T) {
+	requiredGates := []string{"feature1", "feature2", "feature3"}
+
+	// All required gates enabled
+	enabledGates := FeatureGates{
+		"feature1": true,
+		"feature2": true,
+		"feature3": true,
+	}
+
+	missing := ValidateFeatureGates(requiredGates, enabledGates)
+	assert.Empty(t, missing)
+
+	// Some gates disabled
+	enabledGates = FeatureGates{
+		"feature1": true,
+		"feature2": false,
+		"feature3": true,
+	}
+
+	missing = ValidateFeatureGates(requiredGates, enabledGates)
+	assert.ElementsMatch(t, []string{"feature2"}, missing)
+
+	// Missing gates
+	enabledGates = FeatureGates{
+		"feature1": true,
+		// feature2 missing
+		"feature3": true,
+	}
+
+	missing = ValidateFeatureGates(requiredGates, enabledGates)
+	assert.ElementsMatch(t, []string{"feature2"}, missing)
+}
+
+func TestFeatureGateMarkerParser_CommentedMarkers(t *testing.T) {
+	parser := NewFeatureGateMarkerParser()
+
+	// Create a temporary file with commented feature gate markers
+	tempDir := t.TempDir()
+	testFile := filepath.Join(tempDir, "test.go")
+
+	content := `package test
+
+// Example of a feature-gated field:
+// Bar is an experimental field that requires the "experimental-bar" feature gate to be enabled
+// TODO: When controller-tools supports feature gates (issue #1238), use:
+// +kubebuilder:feature-gate=experimental-bar
+// +feature-gate experimental-bar
+// +optional
+// Bar *string ` + "`" + `json:"bar,omitempty"` + "`" + `
+
+type TestSpec struct {
+	// foo is an example field
+	// +optional
+	Foo *string ` + "`" + `json:"foo,omitempty"` + "`" + `
+}
+`
+
+	err := os.WriteFile(testFile, []byte(content), 0644)
+	if err != nil {
+		t.Fatalf("Failed to write test file: %v", err)
+	}
+
+	// Parse the directory
+	markers, err := parser.ParseDirectory(tempDir)
+	if err != nil {
+		t.Fatalf("Failed to parse directory: %v", err)
+	}
+
+	// Should not find any feature gate markers since they're commented out
+	if len(markers) > 0 {
+		t.Errorf("Expected no feature gate markers, but found %d: %v", len(markers), markers)
+	}
+}
+
+func TestFeatureGateMarkerParser_ActiveMarkers(t *testing.T) {
+	parser := NewFeatureGateMarkerParser()
+
+	// Create a temporary file with active feature gate markers
+	tempDir := t.TempDir()
+	testFile := filepath.Join(tempDir, "test.go")
+
+	content := `package test
+
+type TestSpec struct {
+	// foo is an example field
+	// +optional
+	Foo *string ` + "`" + `json:"foo,omitempty"` + "`" + `
+
+	// Bar is an experimental field that requires the "experimental-bar" feature gate to be enabled
+	// +feature-gate experimental-bar
+	// +optional
+	Bar *string ` + "`" + `json:"bar,omitempty"` + "`" + `
+}
+`
+
+	err := os.WriteFile(testFile, []byte(content), 0644)
+	if err != nil {
+		t.Fatalf("Failed to write test file: %v", err)
+	}
+
+	// Parse the directory
+	markers, err := parser.ParseDirectory(tempDir)
+	if err != nil {
+		t.Fatalf("Failed to parse directory: %v", err)
+	}
+
+	// Should find the active feature gate marker
+	if len(markers) != 1 {
+		t.Errorf("Expected 1 feature gate marker, but found %d: %v", len(markers), markers)
+	}
+
+	if markers[0].GateName != "experimental-bar" {
+		t.Errorf("Expected gate name 'experimental-bar', but got '%s'", markers[0].GateName)
+	}
+}
diff --git a/pkg/machinery/featuregate_test.go b/pkg/machinery/featuregate_test.go
new file mode 100644
index 00000000000..d7be0a4f6ed
--- /dev/null
+++ b/pkg/machinery/featuregate_test.go
@@ -0,0 +1,166 @@
+/*
+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 machinery
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseFeatureGates(t *testing.T) {
+	tests := []struct {
+		name        string
+		input       string
+		expected    FeatureGates
+		expectError bool
+	}{
+		{
+			name:     "empty string",
+			input:    "",
+			expected: FeatureGates{},
+		},
+		{
+			name:     "single feature gate",
+			input:    "feature1",
+			expected: FeatureGates{"feature1": true},
+		},
+		{
+			name:     "single feature gate with explicit true",
+			input:    "feature1=true",
+			expected: FeatureGates{"feature1": true},
+		},
+		{
+			name:     "single feature gate with explicit false",
+			input:    "feature1=false",
+			expected: FeatureGates{"feature1": false},
+		},
+		{
+			name:     "multiple feature gates",
+			input:    "feature1,feature2",
+			expected: FeatureGates{"feature1": true, "feature2": true},
+		},
+		{
+			name:     "mixed enabled and disabled",
+			input:    "feature1=true,feature2=false,feature3",
+			expected: FeatureGates{"feature1": true, "feature2": false, "feature3": true},
+		},
+		{
+			name:     "with whitespace",
+			input:    " feature1 , feature2=false , feature3 ",
+			expected: FeatureGates{"feature1": true, "feature2": false, "feature3": true},
+		},
+		{
+			name:        "invalid format",
+			input:       "feature1=invalid",
+			expectError: true,
+		},
+		{
+			name:        "empty feature name",
+			input:       "=true",
+			expectError: true,
+		},
+		{
+			name:        "empty feature name with comma",
+			input:       ",feature1",
+			expectError: true,
+		},
+		{
+			name:        "empty feature name with comma and space",
+			input:       " ,feature1",
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := ParseFeatureGates(tt.input)
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestFeatureGates_IsEnabled(t *testing.T) {
+	gates := FeatureGates{
+		"enabled":  true,
+		"disabled": false,
+	}
+
+	assert.True(t, gates.IsEnabled("enabled"))
+	assert.False(t, gates.IsEnabled("disabled"))
+	assert.False(t, gates.IsEnabled("nonexistent"))
+}
+
+func TestFeatureGates_GetEnabledGates(t *testing.T) {
+	gates := FeatureGates{
+		"enabled1":  true,
+		"enabled2":  true,
+		"disabled1": false,
+		"disabled2": false,
+	}
+
+	enabled := gates.GetEnabledGates()
+	assert.ElementsMatch(t, []string{"enabled1", "enabled2"}, enabled)
+}
+
+func TestFeatureGates_GetDisabledGates(t *testing.T) {
+	gates := FeatureGates{
+		"enabled1":  true,
+		"enabled2":  true,
+		"disabled1": false,
+		"disabled2": false,
+	}
+
+	disabled := gates.GetDisabledGates()
+	assert.ElementsMatch(t, []string{"disabled1", "disabled2"}, disabled)
+}
+
+func TestFeatureGates_String(t *testing.T) {
+	tests := []struct {
+		name     string
+		gates    FeatureGates
+		expected string
+	}{
+		{
+			name:     "empty gates",
+			gates:    FeatureGates{},
+			expected: "",
+		},
+		{
+			name:     "only enabled gates",
+			gates:    FeatureGates{"feature1": true, "feature2": true},
+			expected: "feature1,feature2",
+		},
+		{
+			name:     "mixed gates",
+			gates:    FeatureGates{"feature1": true, "feature2": false},
+			expected: "feature1,feature2=false",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.gates.String()
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
diff --git a/pkg/plugins/golang/v4/api.go b/pkg/plugins/golang/v4/api.go
index 3747dc9de7d..d7be52eec2a 100644
--- a/pkg/plugins/golang/v4/api.go
+++ b/pkg/plugins/golang/v4/api.go
@@ -50,11 +50,17 @@ type createAPISubcommand struct {
 	resourceFlag   *pflag.Flag
 	controllerFlag *pflag.Flag
 
+	// featureGateFlag holds the flag for feature gates
+	featureGateFlag *pflag.Flag
+
 	// force indicates that the resource should be created even if it already exists
 	force bool
 
 	// runMake indicates whether to run make or not after scaffolding APIs
 	runMake bool
+
+	// withFeatureGates indicates whether to include feature gate support
+	withFeatureGates bool
 }
 
 func (p *createAPISubcommand) UpdateMetadata(cliMeta plugin.CLIMetadata, subcmdMeta *plugin.SubcommandMetadata) {
@@ -69,6 +75,9 @@ make generate will be run.
 	subcmdMeta.Examples = fmt.Sprintf(`  # Create a frigates API with Group: ship, Version: v1beta1 and Kind: Frigate
   %[1]s create api --group ship --version v1beta1 --kind Frigate
 
+  # Create an API with feature gate infrastructure for experimental features
+  %[1]s create api --group webapp --version v1 --kind Guestbook --with-feature-gates
+
   # Edit the API Scheme
 
   nano api/v1beta1/frigate_types.go
@@ -96,6 +105,10 @@ func (p *createAPISubcommand) BindFlags(fs *pflag.FlagSet) {
 	fs.BoolVar(&p.force, "force", false,
 		"attempt to create resource even if it already exists")
 
+	fs.BoolVar(&p.withFeatureGates, "with-feature-gates", false,
+		"if specified, include feature gate support in scaffolded files")
+	p.featureGateFlag = fs.Lookup("with-feature-gates")
+
 	p.options = &goPlugin.Options{}
 
 	fs.StringVar(&p.options.Plural, "plural", "", "resource irregular plural form")
@@ -147,6 +160,13 @@ func (p *createAPISubcommand) InjectResource(res *resource.Resource) error {
 
 	p.options.UpdateResource(p.resource, p.config)
 
+	// Auto-detect feature gates if not explicitly set and infrastructure exists
+	if !p.featureGateFlag.Changed {
+		if _, err := os.Stat("internal/featuregates/featuregates.go"); err == nil {
+			p.withFeatureGates = true
+		}
+	}
+
 	if err := p.resource.Validate(); err != nil {
 		return fmt.Errorf("error validating resource: %w", err)
 	}
@@ -180,6 +200,11 @@ func (p *createAPISubcommand) PreScaffold(machinery.Filesystem) error {
 func (p *createAPISubcommand) Scaffold(fs machinery.Filesystem) error {
 	scaffolder := scaffolds.NewAPIScaffolder(p.config, *p.resource, p.force)
 	scaffolder.InjectFS(fs)
+
+	// Set feature gates flag if the scaffolder supports it
+	if fgScaffolder, ok := scaffolder.(scaffolds.FeatureGateScaffolder); ok {
+		fgScaffolder.SetWithFeatureGates(p.withFeatureGates)
+	}
 	if err := scaffolder.Scaffold(); err != nil {
 		return fmt.Errorf("error scaffolding API: %w", err)
 	}
diff --git a/pkg/plugins/golang/v4/init.go b/pkg/plugins/golang/v4/init.go
index 278f5f3bdf3..1d370c0f4f0 100644
--- a/pkg/plugins/golang/v4/init.go
+++ b/pkg/plugins/golang/v4/init.go
@@ -57,6 +57,7 @@ type initSubcommand struct {
 	// flags
 	fetchDeps          bool
 	skipGoVersionCheck bool
+	withFeatureGates   bool
 }
 
 func (p *initSubcommand) UpdateMetadata(cliMeta plugin.CLIMetadata, subcmdMeta *plugin.SubcommandMetadata) {
@@ -74,6 +75,9 @@ func (p *initSubcommand) UpdateMetadata(cliMeta plugin.CLIMetadata, subcmdMeta *
 
   # Initialize a new project defining a specific project version
   %[1]s init --plugins go/v4 --project-version 3
+
+  # Initialize a new project with feature gate infrastructure for experimental features
+  %[1]s init --plugins go/v4 --domain example.org --with-feature-gates
 `, cliMeta.CommandName)
 }
 
@@ -84,6 +88,10 @@ func (p *initSubcommand) BindFlags(fs *pflag.FlagSet) {
 	// dependency args
 	fs.BoolVar(&p.fetchDeps, "fetch-deps", true, "ensure dependencies are downloaded")
 
+	// feature gate args
+	fs.BoolVar(&p.withFeatureGates, "with-feature-gates", false,
+		"if specified, scaffold feature gate infrastructure for experimental functionality")
+
 	// boilerplate args
 	fs.StringVar(&p.license, "license", "apache2",
 		"license to use to boilerplate, may be one of 'apache2', 'none'")
@@ -128,6 +136,10 @@ func (p *initSubcommand) PreScaffold(machinery.Filesystem) error {
 func (p *initSubcommand) Scaffold(fs machinery.Filesystem) error {
 	scaffolder := scaffolds.NewInitScaffolder(p.config, p.license, p.owner, p.commandName)
 	scaffolder.InjectFS(fs)
+	// Set feature gates flag if the scaffolder supports it
+	if fgScaffolder, ok := scaffolder.(scaffolds.FeatureGateScaffolder); ok {
+		fgScaffolder.SetWithFeatureGates(p.withFeatureGates)
+	}
 	if err := scaffolder.Scaffold(); err != nil {
 		return fmt.Errorf("error scaffolding init plugin: %w", err)
 	}
diff --git a/pkg/plugins/golang/v4/scaffolds/api.go b/pkg/plugins/golang/v4/scaffolds/api.go
index aa8c708417a..ac1d69d331d 100644
--- a/pkg/plugins/golang/v4/scaffolds/api.go
+++ b/pkg/plugins/golang/v4/scaffolds/api.go
@@ -19,7 +19,9 @@ package scaffolds
 import (
 	"errors"
 	"fmt"
-	log "log/slog"
+	"log/slog"
+	"os"
+	"path/filepath"
 
 	"github.com/spf13/afero"
 
@@ -46,6 +48,9 @@ type apiScaffolder struct {
 
 	// force indicates whether to scaffold controller files even if it exists or not
 	force bool
+
+	// withFeatureGates indicates whether to include feature gate support
+	withFeatureGates bool
 }
 
 // NewAPIScaffolder returns a new Scaffolder for API/controller creation operations
@@ -62,15 +67,20 @@ func (s *apiScaffolder) InjectFS(fs machinery.Filesystem) {
 	s.fs = fs
 }
 
+// SetWithFeatureGates sets whether to include feature gate support
+func (s *apiScaffolder) SetWithFeatureGates(withFeatureGates bool) {
+	s.withFeatureGates = withFeatureGates
+}
+
 // Scaffold implements cmdutil.Scaffolder
 func (s *apiScaffolder) Scaffold() error {
-	log.Info("Writing scaffold for you to edit...")
+	slog.Info("Writing scaffold for you to edit...")
 
 	// Load the boilerplate
 	boilerplate, err := afero.ReadFile(s.fs.FS, hack.DefaultBoilerplatePath)
 	if err != nil {
 		if errors.Is(err, afero.ErrFileNotFound) {
-			log.Warn("Unable to find boilerplate file."+
+			slog.Warn("Unable to find boilerplate file."+
 				"This file is used to generate the license header in the project.\n"+
 				"Note that controller-gen will also use this. Therefore, ensure that you "+
 				"add the license file or configure your project accordingly.",
@@ -96,9 +106,26 @@ func (s *apiScaffolder) Scaffold() error {
 		return fmt.Errorf("error updating resource: %w", err)
 	}
 
+	// Check if feature gates infrastructure already exists
+	existingFeatureGatesFile := filepath.Join("internal", "featuregates", "featuregates.go")
+	if _, err := os.Stat(existingFeatureGatesFile); err == nil {
+		// Feature gates infrastructure already exists, enable support
+		s.withFeatureGates = true
+		slog.Debug("Detected existing feature gates infrastructure, enabling support")
+	}
+
+	// If using --force, discover existing feature gates before overwriting files
+	var existingGates []string
+	if s.force && doAPI {
+		existingGates = s.discoverFeatureGates()
+	}
+
 	if doAPI {
 		if err := scaffold.Execute(
-			&api.Types{Force: s.force},
+			&api.Types{
+				Force:                     s.force,
+				IncludeFeatureGateExample: s.withFeatureGates,
+			},
 			&api.Group{},
 		); err != nil {
 			return fmt.Errorf("error scaffolding APIs: %w", err)
@@ -115,6 +142,46 @@ func (s *apiScaffolder) Scaffold() error {
 		}
 	}
 
+	// Discover feature gates from newly scaffolded API types
+	newGates := s.discoverFeatureGates()
+	var availableGates []string
+
+	// Merge existing gates with newly discovered ones if we used --force
+	if len(existingGates) > 0 {
+		gateMap := make(map[string]bool)
+
+		// Add existing gates
+		for _, gate := range existingGates {
+			gateMap[gate] = true
+		}
+
+		// Add newly discovered gates (from template)
+		for _, gate := range newGates {
+			gateMap[gate] = true
+		}
+
+		// Create merged list
+		var mergedGates []string
+		for gate := range gateMap {
+			mergedGates = append(mergedGates, gate)
+		}
+
+		availableGates = mergedGates
+	} else {
+		availableGates = newGates
+	}
+
+	// Only generate feature gates infrastructure if requested or if gates were discovered
+	if s.withFeatureGates || len(availableGates) > 0 {
+		// Generate feature gates file
+		featureGatesTemplate := &cmd.FeatureGates{}
+		featureGatesTemplate.AvailableGates = availableGates
+		featureGatesTemplate.IfExistsAction = machinery.OverwriteFile
+		if err := scaffold.Execute(featureGatesTemplate); err != nil {
+			return fmt.Errorf("error scaffolding feature gates: %w", err)
+		}
+	}
+
 	if err := scaffold.Execute(
 		&cmd.MainUpdater{WireResource: doAPI, WireController: doController},
 	); err != nil {
@@ -123,3 +190,68 @@ func (s *apiScaffolder) Scaffold() error {
 
 	return nil
 }
+
+// discoverFeatureGates scans the API directory for feature gate markers
+func (s *apiScaffolder) discoverFeatureGates() []string {
+	mgParser := machinery.NewFeatureGateMarkerParser()
+
+	// Try to parse the API directory
+	apiDir := "api"
+	if s.config.IsMultiGroup() && s.resource.Group != "" {
+		apiDir = filepath.Join("api", s.resource.Group)
+	}
+
+	// Debug: Get current working directory
+	if wd, err := os.Getwd(); err == nil {
+		slog.Debug("Feature gate discovery", "workingDir", wd, "apiDir", apiDir)
+	}
+
+	// Check if the directory exists before trying to parse it
+	if _, err := os.Stat(apiDir); err != nil {
+		slog.Debug("API directory does not exist yet, skipping feature gate discovery", "apiDir", apiDir, "error", err)
+		return []string{}
+	}
+
+	var allMarkers []machinery.FeatureGateMarker
+
+	// Walk through each version directory and parse for feature gates
+	entries, err := os.ReadDir(apiDir)
+	if err != nil {
+		slog.Debug("Error reading API directory", "error", err, "apiDir", apiDir)
+		return []string{}
+	}
+
+	slog.Debug("API directory contents", "apiDir", apiDir, "fileCount", len(entries))
+
+	for _, entry := range entries {
+		slog.Debug("API directory file", "name", entry.Name(), "isDir", entry.IsDir())
+		if entry.IsDir() {
+			versionDir := filepath.Join(apiDir, entry.Name())
+
+			// Use the existing parser to parse the version directory
+			markers, err := mgParser.ParseDirectory(versionDir)
+			if err != nil {
+				slog.Debug("Error parsing version directory for feature gates", "error", err, "versionDir", versionDir)
+				continue
+			}
+
+			slog.Debug("Parsed markers from directory", "versionDir", versionDir, "markerCount", len(markers))
+
+			// Debug: Print all discovered markers
+			for _, marker := range markers {
+				slog.Debug("Found feature gate marker", "gateName", marker.GateName, "line", marker.Line, "file", marker.File)
+			}
+
+			allMarkers = append(allMarkers, markers...)
+		}
+	}
+
+	featureGates := machinery.ExtractFeatureGates(allMarkers)
+	if len(featureGates) > 0 {
+		slog.Debug("Discovered feature gates", "featureGates", featureGates)
+	} else {
+		slog.Debug("No feature gates found in directory", "apiDir", apiDir)
+	}
+
+	return featureGates
+}
diff --git a/pkg/plugins/golang/v4/scaffolds/api_test.go b/pkg/plugins/golang/v4/scaffolds/api_test.go
new file mode 100644
index 00000000000..7d8dbda4794
--- /dev/null
+++ b/pkg/plugins/golang/v4/scaffolds/api_test.go
@@ -0,0 +1,195 @@
+/*
+Copyright 2022 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 scaffolds
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	. "github.com/onsi/gomega"
+
+	"github.com/spf13/afero"
+	"sigs.k8s.io/kubebuilder/v4/pkg/config"
+	v3 "sigs.k8s.io/kubebuilder/v4/pkg/config/v3"
+	"sigs.k8s.io/kubebuilder/v4/pkg/machinery"
+	"sigs.k8s.io/kubebuilder/v4/pkg/model/resource"
+)
+
+// mockConfig implements config.Config for testing
+type mockConfig struct {
+	multiGroup bool
+}
+
+func (m *mockConfig) GetVersion() config.Version                { return config.Version{} }
+func (m *mockConfig) GetCliVersion() string                     { return "" }
+func (m *mockConfig) SetCliVersion(version string) error        { return nil }
+func (m *mockConfig) GetDomain() string                         { return "example.com" }
+func (m *mockConfig) SetDomain(domain string) error             { return nil }
+func (m *mockConfig) GetRepository() string                     { return "" }
+func (m *mockConfig) SetRepository(repository string) error     { return nil }
+func (m *mockConfig) GetProjectName() string                    { return "" }
+func (m *mockConfig) SetProjectName(name string) error          { return nil }
+func (m *mockConfig) GetPluginChain() []string                  { return nil }
+func (m *mockConfig) SetPluginChain(pluginChain []string) error { return nil }
+func (m *mockConfig) IsMultiGroup() bool                        { return m.multiGroup }
+func (m *mockConfig) SetMultiGroup() error                      { return nil }
+func (m *mockConfig) ClearMultiGroup() error                    { return nil }
+func (m *mockConfig) ResourcesLength() int                      { return 0 }
+func (m *mockConfig) HasResource(gvk resource.GVK) bool         { return false }
+func (m *mockConfig) GetResource(gvk resource.GVK) (resource.Resource, error) {
+	return resource.Resource{}, nil
+}
+func (m *mockConfig) GetResources() ([]resource.Resource, error) { return nil, nil }
+func (m *mockConfig) AddResource(res resource.Resource) error    { return nil }
+func (m *mockConfig) UpdateResource(res resource.Resource) error { return nil }
+func (m *mockConfig) HasGroup(group string) bool                 { return false }
+func (m *mockConfig) ListCRDVersions() []string                  { return nil }
+func (m *mockConfig) ListWebhookVersions() []string              { return nil }
+func (m *mockConfig) DecodePluginConfig(key string, configObj interface{}) error {
+	return nil
+}
+func (m *mockConfig) EncodePluginConfig(key string, configObj interface{}) error {
+	return nil
+}
+func (m *mockConfig) MarshalYAML() ([]byte, error) { return nil, nil }
+func (m *mockConfig) UnmarshalYAML([]byte) error   { return nil }
+
+func TestAPIScaffolder_discoverFeatureGates(t *testing.T) {
+	RegisterTestingT(t)
+
+	tests := []struct {
+		name          string
+		config        config.Config
+		resource      resource.Resource
+		expectedGates []string
+	}{
+		{
+			name: "single group project",
+			config: &mockConfig{
+				multiGroup: false,
+			},
+			resource: resource.Resource{
+				GVK: resource.GVK{
+					Group:   "example.com",
+					Version: "v1",
+					Kind:    "MyResource",
+				},
+			},
+			expectedGates: []string{},
+		},
+		{
+			name: "multi group project",
+			config: &mockConfig{
+				multiGroup: true,
+			},
+			resource: resource.Resource{
+				GVK: resource.GVK{
+					Group:   "example.com",
+					Version: "v1",
+					Kind:    "MyResource",
+				},
+			},
+			expectedGates: []string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			scaffolder := NewAPIScaffolder(tt.config, tt.resource, false)
+			apiScaffolder, ok := scaffolder.(*apiScaffolder)
+			if !ok {
+				t.Fatal("Expected apiScaffolder type")
+			}
+
+			// Initialize filesystem to prevent nil pointer dereference
+			apiScaffolder.fs = machinery.Filesystem{FS: afero.NewMemMapFs()}
+
+			gates := apiScaffolder.discoverFeatureGates()
+
+			// In a real test environment, we'd create test files with feature gates
+			// For now, we just verify the function doesn't panic and returns a slice
+			Expect(gates).NotTo(BeNil())
+			Expect(gates).To(BeAssignableToTypeOf([]string{}))
+		})
+	}
+}
+
+func TestAPIScaffolder_NewAPIScaffolder(t *testing.T) {
+	RegisterTestingT(t)
+
+	cfg := v3.New()
+	res := resource.Resource{
+		GVK: resource.GVK{
+			Group:   "example.com",
+			Version: "v1",
+			Kind:    "MyResource",
+		},
+	}
+
+	scaffolder := NewAPIScaffolder(cfg, res, false)
+	Expect(scaffolder).NotTo(BeNil())
+
+	apiScaffolder, ok := scaffolder.(*apiScaffolder)
+	Expect(ok).To(BeTrue())
+
+	Expect(apiScaffolder.config).To(Equal(cfg))
+	Expect(apiScaffolder.resource).To(Equal(res))
+	Expect(apiScaffolder.force).To(BeFalse())
+}
+
+func TestAPIScaffolder_discoverFeatureGates_Testdata(t *testing.T) {
+	// Change to testdata directory
+	oldDir, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Failed to get current directory: %v", err)
+	}
+	defer os.Chdir(oldDir)
+
+	// Change to testdata/project-v4 directory (from pkg/plugins/golang/v4/scaffolds/ to ../../../../../testdata/project-v4)
+	testdataDir := filepath.Join("../../../../../testdata", "project-v4")
+	if err := os.Chdir(testdataDir); err != nil {
+		t.Fatalf("Failed to change to testdata directory: %v", err)
+	}
+
+	cfg := v3.New()
+	res := resource.Resource{
+		GVK: resource.GVK{
+			Group:   "crew.example.com",
+			Version: "v1",
+			Kind:    "Captain",
+		},
+	}
+
+	scaffolder := NewAPIScaffolder(cfg, res, false)
+	apiScaffolder, ok := scaffolder.(*apiScaffolder)
+	if !ok {
+		t.Fatal("Expected apiScaffolder type")
+	}
+
+	// Initialize filesystem to prevent nil pointer dereference
+	apiScaffolder.fs = machinery.Filesystem{FS: afero.NewOsFs()}
+
+	featureGates := apiScaffolder.discoverFeatureGates()
+
+	// The testdata should not contain any feature gate markers by default
+	// since testdata files are auto-generated
+	expectedGates := []string{}
+	if len(featureGates) != len(expectedGates) {
+		t.Errorf("Expected %d feature gates from testdata, but found %d: %v", len(expectedGates), len(featureGates), featureGates)
+	}
+}
diff --git a/pkg/plugins/golang/v4/scaffolds/init.go b/pkg/plugins/golang/v4/scaffolds/init.go
index 5f6bd14218a..5dd557a3af7 100644
--- a/pkg/plugins/golang/v4/scaffolds/init.go
+++ b/pkg/plugins/golang/v4/scaffolds/init.go
@@ -53,11 +53,12 @@ var _ plugins.Scaffolder = &initScaffolder{}
 var kustomizeVersion string
 
 type initScaffolder struct {
-	config          config.Config
-	boilerplatePath string
-	license         string
-	owner           string
-	commandName     string
+	config           config.Config
+	boilerplatePath  string
+	license          string
+	owner            string
+	commandName      string
+	withFeatureGates bool
 
 	// fs is the filesystem that will be used by the scaffolder
 	fs machinery.Filesystem
@@ -79,6 +80,11 @@ func (s *initScaffolder) InjectFS(fs machinery.Filesystem) {
 	s.fs = fs
 }
 
+// SetWithFeatureGates sets whether to scaffold feature gate infrastructure
+func (s *initScaffolder) SetWithFeatureGates(withFeatureGates bool) {
+	s.withFeatureGates = withFeatureGates
+}
+
 // getControllerRuntimeReleaseBranch converts the ControllerRuntime semantic versioning string to a
 // release branch string. Example input: "v0.17.0" -> Output: "release-0.17"
 func getControllerRuntimeReleaseBranch() string {
@@ -155,9 +161,11 @@ func (s *initScaffolder) Scaffold() error {
 		}
 	}
 
-	err := scaffold.Execute(
+	// Build the list of templates to scaffold
+	scaffoldFiles := []machinery.Builder{
 		&cmd.Main{
 			ControllerRuntimeVersion: ControllerRuntimeVersion,
+			WithFeatureGates:         s.withFeatureGates,
 		},
 		&templates.GoMod{
 			ControllerRuntimeVersion: ControllerRuntimeVersion,
@@ -177,7 +185,6 @@ func (s *initScaffolder) Scaffold() error {
 		&templates.Readme{CommandName: s.commandName},
 		&templates.Golangci{},
 		&e2e.Test{},
-		&e2e.WebhookTestUpdater{WireWebhook: false},
 		&e2e.SuiteTest{},
 		&github.E2eTestCi{},
 		&github.TestCi{},
@@ -187,7 +194,14 @@ func (s *initScaffolder) Scaffold() error {
 		&utils.Utils{},
 		&templates.DevContainer{},
 		&templates.DevContainerPostInstallScript{},
-	)
+	}
+
+	// Only add feature gates template if requested
+	if s.withFeatureGates {
+		scaffoldFiles = append(scaffoldFiles, &cmd.FeatureGates{AvailableGates: []string{}})
+	}
+
+	err := scaffold.Execute(scaffoldFiles...)
 	if err != nil {
 		return fmt.Errorf("failed to execute init scaffold: %w", err)
 	}
diff --git a/pkg/plugins/golang/v4/scaffolds/interfaces.go b/pkg/plugins/golang/v4/scaffolds/interfaces.go
new file mode 100644
index 00000000000..3673b480fcc
--- /dev/null
+++ b/pkg/plugins/golang/v4/scaffolds/interfaces.go
@@ -0,0 +1,6 @@
+package scaffolds
+
+// FeatureGateScaffolder interface for scaffolders that support feature gates
+type FeatureGateScaffolder interface {
+	SetWithFeatureGates(bool)
+}
diff --git a/pkg/plugins/golang/v4/scaffolds/internal/templates/api/types.go b/pkg/plugins/golang/v4/scaffolds/internal/templates/api/types.go
index 429b68192d6..538694fb5d5 100644
--- a/pkg/plugins/golang/v4/scaffolds/internal/templates/api/types.go
+++ b/pkg/plugins/golang/v4/scaffolds/internal/templates/api/types.go
@@ -35,6 +35,8 @@ type Types struct {
 	machinery.ResourceMixin
 
 	Force bool
+	// IncludeFeatureGateExample determines whether to include feature gate example in the scaffolded API
+	IncludeFeatureGateExample bool
 }
 
 // SetTemplateDefaults implements machinery.Template
@@ -83,6 +85,15 @@ type {{ .Resource.Kind }}Spec struct {
 	// foo is an example field of {{ .Resource.Kind }}. Edit {{ lower .Resource.Kind }}_types.go to remove/update
 	// +optional	
 	Foo *string ` + "`" + `json:"foo,omitempty"` + "`" + `
+{{- if .IncludeFeatureGateExample }}
+
+	// Example of a feature-gated field:
+	// Bar is an experimental field that requires the "experimental-bar" feature gate to be enabled
+	// +kubebuilder:feature-gate=experimental-bar
+	// +feature-gate experimental-bar
+	// +optional
+	Bar *string ` + "`" + `json:"bar,omitempty"` + "`" + `
+{{- end }}
 }
 
 // {{ .Resource.Kind }}Status defines the observed state of {{ .Resource.Kind }}.
diff --git a/pkg/plugins/golang/v4/scaffolds/internal/templates/cmd/featuregates.go b/pkg/plugins/golang/v4/scaffolds/internal/templates/cmd/featuregates.go
new file mode 100644
index 00000000000..fadeab5cac6
--- /dev/null
+++ b/pkg/plugins/golang/v4/scaffolds/internal/templates/cmd/featuregates.go
@@ -0,0 +1,177 @@
+/*
+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 cmd
+
+import (
+	"sigs.k8s.io/kubebuilder/v4/pkg/machinery"
+)
+
+var _ machinery.Template = &FeatureGates{}
+
+// FeatureGates scaffolds a feature gates package
+type FeatureGates struct {
+	machinery.TemplateMixin
+	machinery.BoilerplateMixin
+	machinery.RepositoryMixin
+
+	// Available feature gates discovered from the project
+	AvailableGates []string
+}
+
+// SetTemplateDefaults implements machinery.Template
+func (f *FeatureGates) SetTemplateDefaults() error {
+	if f.Path == "" {
+		f.Path = "internal/featuregates/featuregates.go"
+	}
+
+	f.TemplateBody = featureGatesTemplate
+
+	return nil
+}
+
+const featureGatesTemplate = `{{ .Boilerplate }}
+
+package featuregates
+
+import (
+	"fmt"
+	"strings"
+)
+
+// FeatureGates represents a map of feature gate names to their enabled state
+type FeatureGates map[string]bool
+
+// GetAvailableFeatureGates returns a list of available feature gates for this project
+func GetAvailableFeatureGates() []string {
+	return []string{
+{{- range .AvailableGates }}
+		"{{ . }}",
+{{- end }}
+	}
+}
+
+// GetFeatureGatesHelpText returns the help text for the feature-gates flag
+func GetFeatureGatesHelpText() string {
+	gates := GetAvailableFeatureGates()
+	if len(gates) == 0 {
+		return "No feature gates available"
+	}
+	return strings.Join(gates, ", ")
+}
+
+// ValidateFeatureGates validates that all specified feature gates are available
+func ValidateFeatureGates(specifiedGates FeatureGates) error {
+	availableGates := GetAvailableFeatureGates()
+	availableMap := make(map[string]bool)
+
+	for _, gate := range availableGates {
+		availableMap[gate] = true
+	}
+
+	var invalidGates []string
+	for gate := range specifiedGates {
+		if !availableMap[gate] {
+			invalidGates = append(invalidGates, gate)
+		}
+	}
+
+	if len(invalidGates) > 0 {
+		return fmt.Errorf("invalid feature gates: %s. Available gates: %s",
+			strings.Join(invalidGates, ", "),
+			strings.Join(availableGates, ", "))
+	}
+
+	return nil
+}
+
+// ParseFeatureGates parses the feature gates string into a map
+func ParseFeatureGates(featureGates string) (FeatureGates, error) {
+	gates := make(FeatureGates)
+	
+	if featureGates == "" {
+		return gates, nil
+	}
+	
+	parts := strings.Split(featureGates, ",")
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		
+		if strings.Contains(part, "=") {
+			kv := strings.SplitN(part, "=", 2)
+			if len(kv) == 2 {
+				gateName := strings.TrimSpace(kv[0])
+				if gateName == "" {
+					return nil, fmt.Errorf("empty feature gate name")
+				}
+				gates[gateName] = strings.TrimSpace(kv[1]) == "true"
+			} else {
+				return nil, fmt.Errorf("invalid feature gate format: %s", part)
+			}
+		} else {
+			if part == "" {
+				return nil, fmt.Errorf("empty feature gate name")
+			}
+			gates[part] = true
+		}
+	}
+	
+	return gates, nil
+}
+
+// IsEnabled checks if a specific feature gate is enabled
+func (fg FeatureGates) IsEnabled(gateName string) bool {
+	return fg[gateName]
+}
+
+// GetEnabledGates returns a list of enabled feature gates
+func (fg FeatureGates) GetEnabledGates() []string {
+	var enabled []string
+	for gate, isEnabled := range fg {
+		if isEnabled {
+			enabled = append(enabled, gate)
+		}
+	}
+	return enabled
+}
+
+// GetDisabledGates returns a list of disabled feature gates
+func (fg FeatureGates) GetDisabledGates() []string {
+	var disabled []string
+	for gate, isEnabled := range fg {
+		if !isEnabled {
+			disabled = append(disabled, gate)
+		}
+	}
+	return disabled
+}
+
+// String returns a string representation of the feature gates
+func (fg FeatureGates) String() string {
+	var parts []string
+	for gate, enabled := range fg {
+		if enabled {
+			parts = append(parts, gate)
+		} else {
+			parts = append(parts, gate+"=false")
+		}
+	}
+	return strings.Join(parts, ",")
+}
+`
diff --git a/pkg/plugins/golang/v4/scaffolds/internal/templates/cmd/main.go b/pkg/plugins/golang/v4/scaffolds/internal/templates/cmd/main.go
index 52cf3886a8f..fb5a96547ba 100644
--- a/pkg/plugins/golang/v4/scaffolds/internal/templates/cmd/main.go
+++ b/pkg/plugins/golang/v4/scaffolds/internal/templates/cmd/main.go
@@ -35,6 +35,7 @@ type Main struct {
 	machinery.RepositoryMixin
 
 	ControllerRuntimeVersion string
+	WithFeatureGates         bool
 }
 
 // SetTemplateDefaults implements machinery.Template
@@ -248,6 +249,10 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/metrics/filters"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
 	metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server"
+	{{- if .WithFeatureGates }}
+	
+	featuregates "{{ .Repo }}/internal/featuregates"
+	{{- end }}
 	%s
 )
 
@@ -271,6 +276,9 @@ func main() {
 	var probeAddr string
 	var secureMetrics bool
 	var enableHTTP2 bool
+	{{- if .WithFeatureGates }}
+	var featureGates string
+	{{- end }}
 	var tlsOpts []func(*tls.Config)
 	flag.StringVar(&metricsAddr, "metrics-bind-address", "0", "The address the metrics endpoint binds to. " +
 		"Use :8443 for HTTPS or :8080 for HTTP, or leave as 0 to disable the metrics service.")
@@ -289,12 +297,32 @@ func main() {
 	flag.StringVar(&metricsCertKey, "metrics-cert-key", "tls.key", "The name of the metrics server key file.")
 	flag.BoolVar(&enableHTTP2, "enable-http2", false,
 		"If set, HTTP/2 will be enabled for the metrics and webhook servers")
+	{{- if .WithFeatureGates }}
+	flag.StringVar(&featureGates, "feature-gates", "", "A set of key=value pairs that describe feature gates for alpha/experimental features. " +
+		"Example: --feature-gates \"gate1=true,gate2=false\". " +
+		"Options are: "+featuregates.GetFeatureGatesHelpText())
+	{{- end }}
 	opts := zap.Options{
 		Development: true,
 	}
 	opts.BindFlags(flag.CommandLine)
 	flag.Parse()
 
+	{{- if .WithFeatureGates }}
+	// Parse feature gates
+	parsedFeatureGates, err := featuregates.ParseFeatureGates(featureGates)
+	if err != nil {
+		setupLog.Error(err, "failed to parse feature gates")
+		os.Exit(1)
+	}
+
+	// Validate feature gates
+	if err := featuregates.ValidateFeatureGates(parsedFeatureGates); err != nil {
+		setupLog.Error(err, "invalid feature gates")
+		os.Exit(1)
+	}
+	{{- end }}
+
 	ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts)))
 
 	// if the enable-http2 flag is false (the default), http/2 should be disabled
diff --git a/test/e2e/featuregates/featuregates_test.go b/test/e2e/featuregates/featuregates_test.go
new file mode 100644
index 00000000000..bf9319ae554
--- /dev/null
+++ b/test/e2e/featuregates/featuregates_test.go
@@ -0,0 +1,217 @@
+/*
+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 featuregates
+
+import (
+	"os"
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	"sigs.k8s.io/kubebuilder/v4/pkg/machinery"
+)
+
+func TestFeatureGates(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Feature Gates Unit Tests Suite")
+}
+
+var _ = Describe("Feature Gate Parsing", func() {
+	It("should parse valid boolean feature gate values", func() {
+		gates, err := machinery.ParseFeatureGates("test-gate=true,another-gate=false")
+		Expect(err).NotTo(HaveOccurred())
+		Expect(gates).To(HaveKeyWithValue("test-gate", true))
+		Expect(gates).To(HaveKeyWithValue("another-gate", false))
+	})
+
+	It("should reject invalid feature gate values", func() {
+		_, err := machinery.ParseFeatureGates("test-gate=maybe")
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("must be 'true' or 'false'"))
+	})
+
+	It("should handle empty input", func() {
+		gates, err := machinery.ParseFeatureGates("")
+		Expect(err).NotTo(HaveOccurred())
+		Expect(gates).To(BeEmpty())
+	})
+
+	It("should reject malformed input", func() {
+		// Test various malformed inputs
+		invalidInputs := []string{
+			"InvalidFormat",      // CamelCase not allowed
+			"invalid_underscore", // Underscores not allowed
+			"invalid.dot",        // Dots not allowed
+			"invalid space",      // Spaces not allowed
+			"=true",              // Empty name
+			"feature=",           // Empty value
+			"feature=maybe",      // Invalid boolean value
+		}
+
+		for _, input := range invalidInputs {
+			_, err := machinery.ParseFeatureGates(input)
+			Expect(err).To(HaveOccurred(), "Expected error for input: %s", input)
+		}
+	})
+})
+
+var _ = Describe("Feature Gate Marker Discovery", func() {
+	var parser *machinery.FeatureGateMarkerParser
+
+	BeforeEach(func() {
+		parser = machinery.NewFeatureGateMarkerParser()
+	})
+
+	It("should discover feature gate markers in Go source files", func() {
+		// Create a temporary directory and file for testing
+		tempDir := GinkgoT().TempDir()
+		testFile := tempDir + "/test_types.go"
+
+		source := `package v1
+
+type TestSpec struct {
+	// Regular field without feature gate
+	Name string ` + "`json:\"name\"`" + `
+
+	// +feature-gate experimental-field
+	// +optional
+	ExperimentalField *string ` + "`json:\"experimentalField,omitempty\"`" + `
+
+	// +feature-gate another-experimental
+	// This field requires the another-experimental gate to be enabled
+	// +optional  
+	AnotherField *int ` + "`json:\"anotherField,omitempty\"`" + `
+}
+`
+		err := os.WriteFile(testFile, []byte(source), 0644)
+		Expect(err).NotTo(HaveOccurred())
+
+		markers, err := parser.ParseFile(testFile)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(markers).To(HaveLen(2))
+
+		gates := machinery.ExtractFeatureGates(markers)
+		Expect(gates).To(ContainElements("experimental-field", "another-experimental"))
+	})
+
+	It("should handle source code without feature gates", func() {
+		// Create a temporary directory and file for testing
+		tempDir := GinkgoT().TempDir()
+		testFile := tempDir + "/test_types.go"
+
+		source := `package v1
+
+type TestSpec struct {
+	Name string ` + "`json:\"name\"`" + `
+	Count int ` + "`json:\"count\"`" + `
+}
+`
+		err := os.WriteFile(testFile, []byte(source), 0644)
+		Expect(err).NotTo(HaveOccurred())
+
+		markers, err := parser.ParseFile(testFile)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(markers).To(BeEmpty())
+
+		gates := machinery.ExtractFeatureGates(markers)
+		Expect(gates).To(BeEmpty())
+	})
+
+	It("should ignore commented out feature gate markers", func() {
+		// Create a temporary directory and file for testing
+		tempDir := GinkgoT().TempDir()
+		testFile := tempDir + "/test_types.go"
+
+		source := `package v1
+
+type TestSpec struct {
+	// This is a comment about feature gates but not a marker
+	// +feature-gate experimental-field
+	ActiveField string ` + "`json:\"activeField\"`" + `
+
+	// // +feature-gate commented-out-gate
+	// This feature gate marker is commented out
+	InactiveField string ` + "`json:\"inactiveField\"`" + `
+}
+`
+		err := os.WriteFile(testFile, []byte(source), 0644)
+		Expect(err).NotTo(HaveOccurred())
+
+		markers, err := parser.ParseFile(testFile)
+		Expect(err).NotTo(HaveOccurred())
+		Expect(markers).To(HaveLen(1))
+
+		gates := machinery.ExtractFeatureGates(markers)
+		Expect(gates).To(ContainElement("experimental-field"))
+		Expect(gates).NotTo(ContainElement("commented-out-gate"))
+	})
+})
+
+var _ = Describe("Feature Gate Validation", func() {
+	It("should validate feature gate names", func() {
+		validNames := []string{
+			"valid-name",
+			"another-valid-name",
+			"alpha-feature",
+			"beta-api",
+			"feature1",
+			"a",
+			"experimental-feature-v2",
+		}
+
+		for _, name := range validNames {
+			gates, err := machinery.ParseFeatureGates(name + "=true")
+			Expect(err).NotTo(HaveOccurred(), "Expected %s to be valid", name)
+			Expect(gates).To(HaveKeyWithValue(name, true))
+		}
+	})
+
+	It("should reject invalid feature gate names", func() {
+		invalidNames := []string{
+			"InvalidCamelCase",   // CamelCase not allowed
+			"invalid_underscore", // Underscores not allowed
+			"invalid.dot",        // Dots not allowed
+			"invalid space",      // Spaces not allowed
+			"UPPERCASE",          // Uppercase not allowed
+			"feature-",           // Cannot end with hyphen
+			"-feature",           // Cannot start with hyphen
+			"feature--name",      // Double hyphens not allowed
+			"123-feature",        // Cannot start with number
+		}
+
+		for _, name := range invalidNames {
+			_, err := machinery.ParseFeatureGates(name + "=true")
+			Expect(err).To(HaveOccurred(), "Expected error for name: %s", name)
+			Expect(err.Error()).To(ContainSubstring("invalid feature gate name"))
+		}
+	})
+
+	It("should reject truly invalid formats", func() {
+		invalidInputs := []string{
+			"=true",                                // Empty name
+			"feature=maybe",                        // Invalid boolean value
+			"feature=",                             // Empty value
+			"valid-feature=TRUE,invalid_name=true", // Mix of valid and invalid
+		}
+
+		for _, input := range invalidInputs {
+			_, err := machinery.ParseFeatureGates(input)
+			Expect(err).To(HaveOccurred(), "Expected error for input: %s", input)
+		}
+	})
+})
diff --git a/test/e2e/setup.sh b/test/e2e/setup.sh
index 231c335127d..c6909d54746 100755
--- a/test/e2e/setup.sh
+++ b/test/e2e/setup.sh
@@ -66,4 +66,5 @@ function test_cluster {
 
   go test $(dirname "$0")/deployimage $flags -timeout 30m
   go test $(dirname "$0")/v4 $flags -timeout 30m
+  go test $(dirname "$0")/v4/featuregates $flags -timeout 30m
 }
diff --git a/test/e2e/v4/featuregates/featuregate_cluster_test.go b/test/e2e/v4/featuregates/featuregate_cluster_test.go
new file mode 100644
index 00000000000..f37f7b8134a
--- /dev/null
+++ b/test/e2e/v4/featuregates/featuregate_cluster_test.go
@@ -0,0 +1,403 @@
+/*
+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 t		It("should respect --feature-gates flag in deployment", func() {
+			By("initializing a project with feature gates")
+			err := kbc.Init(
+				"--plugins", "go.kubebuilder.io/v4",
+				"--domain", kbc.Domain,
+				"--with-feature-gates",
+			)
+			Expect(err).NotTo(HaveOccurred())ting, 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 featuregates
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	"sigs.k8s.io/kubebuilder/v4/pkg/plugin/util"
+	"sigs.k8s.io/kubebuilder/v4/test/e2e/utils"
+)
+
+var _ = Describe("Feature Gates Cluster E2E", func() {
+	var (
+		kbc *utils.TestContext
+	)
+
+	BeforeEach(func() {
+		var err error
+		kbc, err = utils.NewTestContext(util.KubebuilderBinName, "GO111MODULE=on")
+		Expect(err).NotTo(HaveOccurred())
+		Expect(kbc.Prepare()).To(Succeed())
+	})
+
+	AfterEach(func() {
+		By("cleaning up created resources")
+		_ = kbc.Make("undeploy")
+		_ = kbc.Make("uninstall")
+		kbc.Destroy()
+	})
+
+	Context("when deploying a controller with feature gates", func() {
+		It("should validate feature gate behavior in cluster logs", func() {
+			By("initializing a project with feature gates")
+			err := kbc.Init(
+				"--plugins", "go.kubebuilder.io/v4",
+				"--domain", kbc.Domain,
+				"--with-feature-gates",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("creating API with controller")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--make=false",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("adding feature gate markers to the API types")
+			typesFile := filepath.Join(kbc.Dir, "api", kbc.Version, strings.ToLower(kbc.Kind)+"_types.go")
+
+			// Add a feature gate field to the API
+			experimentalField := `
+	// ExperimentalField is a feature-gated field for testing
+	// +feature-gate experimental-field
+	// +optional
+	ExperimentalField *string ` + "`" + `json:"experimentalField,omitempty"` + "`"
+
+			err = util.InsertCode(
+				typesFile,
+				"Foo *string `json:\"foo,omitempty\"`",
+				experimentalField,
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("regenerating the project to discover feature gates")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--force",
+				"--make=false",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("adding feature gate logging to the controller")
+			controllerFile := filepath.Join(kbc.Dir, "internal", "controller", strings.ToLower(kbc.Kind)+"_controller.go")
+
+			// Add feature gate validation logging
+			featureGateLogic := `
+	// Feature gate validation and logging
+	if featureGates.IsEnabled("experimental-field") {
+		log.Info("experimental feature gate enabled", "feature", "experimental-field")
+		if obj.Spec.ExperimentalField != nil {
+			log.Info("experimental field found", "value", *obj.Spec.ExperimentalField)
+		}
+	} else {
+		log.Info("experimental feature gate disabled", "feature", "experimental-field")
+	}`
+
+			err = util.InsertCode(
+				controllerFile,
+				"// TODO(user): your logic here.",
+				featureGateLogic,
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("adding feature gates import to controller")
+			err = util.InsertCode(
+				controllerFile,
+				`"sigs.k8s.io/controller-runtime/pkg/reconcile"`,
+				`
+	"sigs.k8s.io/kubebuilder/v4/internal/featuregates"`,
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("updating controller to use global feature gates")
+			err = util.ReplaceInFile(
+				controllerFile,
+				"func (r *"+kbc.Kind+"Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {",
+				`func (r *`+kbc.Kind+`Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
+	log := log.FromContext(ctx)
+
+	// Get the object
+	var obj `+strings.ToLower(kbc.Group)+kbc.Version+`.`+kbc.Kind+`
+	if err := r.Get(ctx, req.NamespacedName, &obj); err != nil {
+		return ctrl.Result{}, client.IgnoreNotFound(err)
+	}
+
+	// Get global feature gates (this should be passed from main.go in real implementation)
+	featureGates := featuregates.FeatureGates{
+		"experimental-field": true, // For testing, enable the feature gate
+	}`,
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("building the project")
+			err = kbc.Make("all")
+			Expect(err).NotTo(HaveOccurred())
+
+			By("building the controller image")
+			err = kbc.Make("docker-build", "IMG="+kbc.ImageName)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("loading the controller docker image into the kind cluster")
+			err = kbc.LoadImageToKindCluster()
+			Expect(err).NotTo(HaveOccurred())
+
+			By("deploying the controller-manager with feature gates enabled")
+			cmd := exec.Command("make", "deploy", "IMG="+kbc.ImageName)
+			_, err = kbc.Run(cmd)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("creating a sample CR to trigger reconciliation")
+			sampleFile := filepath.Join("config", "samples", 
+				strings.ToLower(kbc.Group)+"_"+kbc.Version+"_"+strings.ToLower(kbc.Kind)+".yaml")
+			
+			// Update sample to include feature-gated field
+			sampleContent := fmt.Sprintf(`apiVersion: %s/%s
+kind: %s
+metadata:
+  labels:
+    app.kubernetes.io/name: %s
+    app.kubernetes.io/managed-by: kustomize
+  name: %s-sample
+  namespace: %s-system
+spec:
+  foo: "test"
+  experimentalField: "feature-gate-test-value"
+`, kbc.Group+"."+kbc.Domain, kbc.Version, kbc.Kind, 
+   strings.ToLower(kbc.Kind), strings.ToLower(kbc.Kind), strings.ToLower(kbc.Kind))
+
+			err = os.WriteFile(sampleFile, []byte(sampleContent), 0644)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("applying the sample CR")
+			EventuallyWithOffset(1, func() error {
+				cmd := exec.Command("kubectl", "apply", "-f", sampleFile)
+				_, err := kbc.Run(cmd)
+				return err
+			}, time.Minute, time.Second).Should(Succeed())
+
+			By("waiting for controller pod to be ready")
+			EventuallyWithOffset(1, func() error {
+				cmd := exec.Command("kubectl", "get", "pods", "-n", kbc.Kind+"-system", 
+					"-l", "control-plane=controller-manager", "--field-selector=status.phase=Running")
+				out, err := kbc.Run(cmd)
+				if err != nil {
+					return err
+				}
+				if !strings.Contains(string(out), "Running") {
+					return fmt.Errorf("controller pod not ready yet")
+				}
+				return nil
+			}, 2*time.Minute, 5*time.Second).Should(Succeed())
+
+			By("checking controller logs for feature gate messages")
+			EventuallyWithOffset(1, func() error {
+				// Get controller pod name
+				cmd := exec.Command("kubectl", "get", "pods", "-n", kbc.Kind+"-system",
+					"-l", "control-plane=controller-manager", "-o", "jsonpath={.items[0].metadata.name}")
+				out, err := kbc.Run(cmd)
+				if err != nil {
+					return err
+				}
+				podName := strings.TrimSpace(string(out))
+
+				// Get logs
+				cmd = exec.Command("kubectl", "logs", "-n", kbc.Kind+"-system", podName, "-c", "manager")
+				out, err = kbc.Run(cmd)
+				if err != nil {
+					return err
+				}
+				logs := string(out)
+
+				// Validate expected log messages
+				if !strings.Contains(logs, "experimental feature gate enabled") {
+					return fmt.Errorf("expected 'experimental feature gate enabled' not found in logs")
+				}
+
+				if !strings.Contains(logs, "experimental field found") {
+					return fmt.Errorf("expected 'experimental field found' not found in logs")
+				}
+
+				if !strings.Contains(logs, "feature-gate-test-value") {
+					return fmt.Errorf("expected feature gate test value not found in logs")
+				}
+
+				return nil
+			}, 3*time.Minute, 10*time.Second).Should(Succeed())
+
+			By("testing with feature gate disabled")
+			// Update the deployment to disable feature gates
+			err = util.ReplaceInFile(
+				controllerFile,
+				`"experimental-field": true, // For testing, enable the feature gate`,
+				`"experimental-field": false, // For testing, disable the feature gate`,
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("rebuilding and redeploying with disabled feature gate")
+			err = kbc.Make("docker-build", "IMG="+kbc.ImageName)
+			Expect(err).NotTo(HaveOccurred())
+
+			err = kbc.LoadImageToKindCluster()
+			Expect(err).NotTo(HaveOccurred())
+
+			cmd = exec.Command("make", "deploy", "IMG="+kbc.ImageName)
+			_, err = kbc.Run(cmd)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("triggering reconciliation again")
+			// Delete and recreate the CR to trigger reconciliation
+			cmd = exec.Command("kubectl", "delete", "-f", sampleFile)
+			kbc.Run(cmd) // Ignore errors
+
+			EventuallyWithOffset(1, func() error {
+				cmd := exec.Command("kubectl", "apply", "-f", sampleFile)
+				_, err := kbc.Run(cmd)
+				return err
+			}, time.Minute, time.Second).Should(Succeed())
+
+			By("checking logs for disabled feature gate message")
+			EventuallyWithOffset(1, func() error {
+				// Get controller pod name
+				cmd := exec.Command("kubectl", "get", "pods", "-n", kbc.Kind+"-system",
+					"-l", "control-plane=controller-manager", "-o", "jsonpath={.items[0].metadata.name}")
+				out, err := kbc.Run(cmd)
+				if err != nil {
+					return err
+				}
+				podName := strings.TrimSpace(string(out))
+
+				// Get recent logs
+				cmd = exec.Command("kubectl", "logs", "-n", kbc.Kind+"-system", podName, "-c", "manager", "--tail=50")
+				out, err = kbc.Run(cmd)
+				if err != nil {
+					return err
+				}
+				logs := string(out)
+
+				// Validate disabled feature gate message
+				if !strings.Contains(logs, "experimental feature gate disabled") {
+					return fmt.Errorf("expected 'experimental feature gate disabled' not found in recent logs")
+				}
+
+				return nil
+			}, 2*time.Minute, 10*time.Second).Should(Succeed())
+		})
+	})
+
+	Context("when deploying with feature gates via command line", func() {
+		It("should respect --feature-gates flag in deployment", func() {
+			By("initializing a project with feature gates")
+			err := kbc.Init(
+				"--plugins", "go.kubebuilder.io/v4",
+				"--domain", kbc.Domain,
+				"--with-feature-gates",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("creating API with controller")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--make=false",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("updating main.go to log feature gate initialization")
+			mainFile := filepath.Join(kbc.Dir, "cmd", "main.go")
+			
+			// Add logging after feature gate parsing
+			err = util.InsertCode(
+				mainFile,
+				"setupLog.Error(err, \"invalid feature gates\")",
+				`
+	setupLog.Info("Feature gates initialized", "gates", parsedFeatureGates.String())`,
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("updating manager deployment to include feature gates flag")
+			managerFile := filepath.Join("config", "manager", "manager.yaml")
+			
+			err = util.ReplaceInFile(
+				managerFile,
+				"- --leader-elect",
+				`- --leader-elect
+        - --feature-gates=experimental-gate=true`,
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("building and deploying the controller")
+			err = kbc.Make("all")
+			Expect(err).NotTo(HaveOccurred())
+
+			err = kbc.Make("docker-build", "IMG="+kbc.ImageName)
+			Expect(err).NotTo(HaveOccurred())
+
+			err = kbc.LoadImageToKindCluster()
+			Expect(err).NotTo(HaveOccurred())
+
+			cmd := exec.Command("make", "deploy", "IMG="+kbc.ImageName)
+			_, err = kbc.Run(cmd)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("checking that feature gates are initialized in pod logs")
+			EventuallyWithOffset(1, func() error {
+				// Get controller pod name
+				cmd := exec.Command("kubectl", "get", "pods", "-n", kbc.Kind+"-system",
+					"-l", "control-plane=controller-manager", "-o", "jsonpath={.items[0].metadata.name}")
+				out, err := kbc.Run(cmd)
+				if err != nil {
+					return err
+				}
+				podName := strings.TrimSpace(string(out))
+
+				// Get logs
+				cmd = exec.Command("kubectl", "logs", "-n", kbc.Kind+"-system", podName, "-c", "manager")
+				out, err = kbc.Run(cmd)
+				if err != nil {
+					return err
+				}
+				logs := string(out)
+
+				// Validate feature gate initialization log
+				if !strings.Contains(logs, "Feature gates initialized") {
+					return fmt.Errorf("expected 'Feature gates initialized' not found in logs")
+				}
+
+				if !strings.Contains(logs, "experimental-gate") {
+					return fmt.Errorf("expected 'experimental-gate' not found in logs")
+				}
+
+				return nil
+			}, 2*time.Minute, 10*time.Second).Should(Succeed())
+		})
+	})
+})
diff --git a/test/e2e/v4/featuregates/featuregates_suite_test.go b/test/e2e/v4/featuregates/featuregates_suite_test.go
new file mode 100644
index 00000000000..fccb153f040
--- /dev/null
+++ b/test/e2e/v4/featuregates/featuregates_suite_test.go
@@ -0,0 +1,29 @@
+/*
+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 featuregates
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestFeatureGatesCluster(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Feature Gates Cluster E2E Suite")
+}
diff --git a/test/e2e/v4/featuregates_discovery_test.go b/test/e2e/v4/featuregates_discovery_test.go
new file mode 100644
index 00000000000..ca7fb6019a6
--- /dev/null
+++ b/test/e2e/v4/featuregates_discovery_test.go
@@ -0,0 +1,221 @@
+/*
+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 v4
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	"sigs.k8s.io/kubebuilder/v4/pkg/machinery"
+	"sigs.k8s.io/kubebuilder/v4/pkg/plugin/util"
+	"sigs.k8s.io/kubebuilder/v4/test/e2e/utils"
+)
+
+var _ = Describe("Feature Gates Discovery", func() {
+	var kbc *utils.TestContext
+
+	BeforeEach(func() {
+		var err error
+		kbc, err = utils.NewTestContext(util.KubebuilderBinName, "GO111MODULE=on")
+		Expect(err).NotTo(HaveOccurred())
+		Expect(kbc.Prepare()).To(Succeed())
+	})
+
+	AfterEach(func() {
+		By("cleaning up test context")
+		kbc.Destroy()
+	})
+
+	Context("when parsing testdata project", func() {
+		It("should NOT discover feature gate markers from captain_types.go by default", func() {
+			By("parsing the testdata project API types")
+			parser := machinery.NewFeatureGateMarkerParser()
+			markers, err := parser.ParseFile("../../../testdata/project-v4/api/v1/captain_types.go")
+			Expect(err).NotTo(HaveOccurred())
+			
+			By("verifying no feature gates are found in clean testdata")
+			// Testdata files are auto-generated and should not contain feature gate markers by default
+			Expect(markers).To(BeEmpty(), "Clean testdata should not contain feature gate markers")
+		})
+	})
+
+	Context("when parsing files with commented fields", func() {
+		It("should ignore commented feature gate markers", func() {
+			By("creating a temporary file with commented feature gate markers")
+			tempContent := `package test
+
+type TestStruct struct {
+	// This field is commented out and should not be discovered
+	// +feature-gate commented-feature
+	// Field *string ` + "`" + `json:"field,omitempty"` + "`" + `
+
+	// This field is active and should be discovered
+	// +feature-gate active-feature
+	ActiveField *string ` + "`" + `json:"activeField,omitempty"` + "`" + `
+}
+`
+
+			By("writing temporary file")
+			tmpFile, err := os.CreateTemp("", "featuregate_test_*.go")
+			Expect(err).NotTo(HaveOccurred())
+			defer os.Remove(tmpFile.Name())
+
+			_, err = tmpFile.WriteString(tempContent)
+			Expect(err).NotTo(HaveOccurred())
+			tmpFile.Close()
+
+			By("parsing the temporary file")
+			parser := machinery.NewFeatureGateMarkerParser()
+			markers, err := parser.ParseFile(tmpFile.Name())
+			Expect(err).NotTo(HaveOccurred())
+
+			By("extracting feature gate names")
+			featureGates := machinery.ExtractFeatureGates(markers)
+
+			By("verifying only active feature gates are discovered")
+			Expect(featureGates).To(ContainElement("active-feature"), "Should discover active feature gate")
+			Expect(featureGates).NotTo(ContainElement("commented-feature"), "Should NOT discover commented feature gate")
+
+			GinkgoWriter.Printf("Discovered feature gates: %v\n", featureGates)
+		})
+	})
+
+	Context("when parsing feature gate strings", func() {
+		It("should handle various feature gate parsing scenarios", func() {
+			testCases := []struct {
+				name     string
+				input    string
+				expected map[string]bool
+				hasError bool
+			}{
+				{
+					name:     "empty string",
+					input:    "",
+					expected: map[string]bool{},
+					hasError: false,
+				},
+				{
+					name:     "single feature gate",
+					input:    "experimental-bar",
+					expected: map[string]bool{"experimental-bar": true},
+					hasError: false,
+				},
+				{
+					name:  "multiple feature gates",
+					input: "experimental-bar,advanced-features",
+					expected: map[string]bool{
+						"experimental-bar":  true,
+						"advanced-features": true,
+					},
+					hasError: false,
+				},
+				{
+					name:  "mixed enabled and disabled",
+					input: "experimental-bar=true,advanced-features=false",
+					expected: map[string]bool{
+						"experimental-bar":  true,
+						"advanced-features": false,
+					},
+					hasError: false,
+				},
+				{
+					name:     "invalid format",
+					input:    "experimental-bar=invalid",
+					expected: nil,
+					hasError: true,
+				},
+			}
+
+			for _, tc := range testCases {
+				By("testing scenario: " + tc.name)
+				result, err := machinery.ParseFeatureGates(tc.input)
+
+				if tc.hasError {
+					Expect(err).To(HaveOccurred())
+				} else {
+					Expect(err).NotTo(HaveOccurred())
+					Expect(result).To(Equal(machinery.FeatureGates(tc.expected)))
+				}
+			}
+		})
+	})
+
+	Context("when scaffolding a project with feature gates", func() {
+		It("should generate feature gates file correctly", func() {
+			By("initializing a project")
+			err := kbc.Init(
+				"--plugins", "go/v4",
+				"--project-version", "3",
+				"--domain", kbc.Domain,
+			)
+			Expect(err).NotTo(HaveOccurred(), "Failed to initialize project")
+
+			By("creating API with feature gate markers")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--make=false",
+			)
+			Expect(err).NotTo(HaveOccurred(), "Failed to create API definition")
+
+			By("adding feature gate markers to the API types")
+			apiTypesFile := filepath.Join(kbc.Dir, "api", kbc.Version, strings.ToLower(kbc.Kind)+"_types.go")
+
+			// Add a feature gate marker to the spec
+			err = util.InsertCode(
+				apiTypesFile,
+				"// +optional\n\tFoo *string `json:\"foo,omitempty\"`",
+				"\n\n\t// +feature-gate experimental-feature",
+			)
+			Expect(err).NotTo(HaveOccurred(), "Failed to add feature gate marker")
+
+			// Add a field after the marker
+			err = util.InsertCode(
+				apiTypesFile,
+				"// +feature-gate experimental-feature",
+				"\n\tExperimentalField *string `json:\"experimentalField,omitempty\"`",
+			)
+			Expect(err).NotTo(HaveOccurred(), "Failed to add experimental field")
+
+			By("regenerating the project to discover feature gates")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--make=false",
+				"--force",
+			)
+			Expect(err).NotTo(HaveOccurred(), "Failed to regenerate project")
+
+			By("verifying feature gates file was generated")
+			featureGatesFile := filepath.Join(kbc.Dir, "internal", "featuregates", "featuregates.go")
+			Expect(featureGatesFile).To(BeAnExistingFile())
+
+			By("verifying feature gates file contains the discovered feature gate")
+			hasContent, err := util.HasFileContentWith(featureGatesFile, "experimental-feature")
+			Expect(err).NotTo(HaveOccurred())
+			Expect(hasContent).To(BeTrue(), "Feature gates file should contain the discovered feature gate")
+		})
+	})
+})
diff --git a/test/e2e/v4/featuregates_test.go b/test/e2e/v4/featuregates_test.go
new file mode 100644
index 00000000000..05ef2250490
--- /dev/null
+++ b/test/e2e/v4/featuregates_test.go
@@ -0,0 +1,240 @@
+/*
+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 v4
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+
+	pluginutil "sigs.k8s.io/kubebuilder/v4/pkg/plugin/util"
+	"sigs.k8s.io/kubebuilder/v4/test/e2e/utils"
+)
+
+var _ = Describe("Feature Gates", func() {
+	Context("project with feature gates", func() {
+		var (
+			kbc *utils.TestContext
+		)
+
+		BeforeEach(func() {
+			var err error
+			kbc, err = utils.NewTestContext(pluginutil.KubebuilderBinName, "GO111MODULE=on")
+			Expect(err).NotTo(HaveOccurred())
+			Expect(kbc).NotTo(BeNil())
+
+			kbc.Domain = "example.com"
+			kbc.Group = "crew"
+			kbc.Version = "v1"
+			kbc.Kind = "Captain"
+
+			By("preparing the test environment")
+			Expect(kbc.Prepare()).To(Succeed())
+		})
+
+		AfterEach(func() {
+			By("destroying directory")
+			kbc.Destroy()
+		})
+
+		It("should scaffold a project with feature gates", func() {
+			By("initializing a project")
+			err := kbc.Init(
+				"--domain", kbc.Domain,
+				"--with-feature-gates",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("creating API with feature gates")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--make=false",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("verifying feature gates file was generated")
+			featureGatesFile := filepath.Join(kbc.Dir, "internal", "featuregates", "featuregates.go")
+			Expect(featureGatesFile).To(BeAnExistingFile())
+
+			By("verifying main.go has feature gates flag")
+			mainFile := filepath.Join(kbc.Dir, "cmd", "main.go")
+			Expect(mainFile).To(BeAnExistingFile())
+			mainContent, err := os.ReadFile(mainFile)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(string(mainContent)).To(ContainSubstring("--feature-gates"))
+			Expect(string(mainContent)).To(ContainSubstring("featuregates"))
+
+			By("verifying API types have feature gate example")
+			typesFile := filepath.Join(kbc.Dir, "api", kbc.Version, strings.ToLower(kbc.Kind)+"_types.go")
+			Expect(typesFile).To(BeAnExistingFile())
+			typesContent, err := os.ReadFile(typesFile)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(string(typesContent)).To(ContainSubstring("+feature-gate"))
+		})
+
+		It("should NOT scaffold feature gates by default", func() {
+			By("initializing a project without feature gates flag")
+			err := kbc.Init(
+				"--domain", kbc.Domain,
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("creating API without feature gates flag")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--make=false",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("verifying feature gates file was NOT generated")
+			featureGatesFile := filepath.Join(kbc.Dir, "internal", "featuregates", "featuregates.go")
+			Expect(featureGatesFile).NotTo(BeAnExistingFile())
+
+			By("verifying main.go does NOT have feature gates flag")
+			mainFile := filepath.Join(kbc.Dir, "cmd", "main.go")
+			Expect(mainFile).To(BeAnExistingFile())
+			mainContent, err := os.ReadFile(mainFile)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(string(mainContent)).NotTo(ContainSubstring("--feature-gates"))
+			Expect(string(mainContent)).NotTo(ContainSubstring("featuregates"))
+
+			By("verifying API types do NOT have feature gate example")
+			typesFile := filepath.Join(kbc.Dir, "api", kbc.Version, strings.ToLower(kbc.Kind)+"_types.go")
+			Expect(typesFile).To(BeAnExistingFile())
+			typesContent, err := os.ReadFile(typesFile)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(string(typesContent)).NotTo(ContainSubstring("+feature-gate"))
+		})
+
+		It("should discover feature gates from API types", func() {
+			By("initializing a project")
+			err := kbc.Init(
+				"--domain", kbc.Domain,
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("creating API")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--make=false",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("adding custom feature gates to the API types")
+			typesFile := filepath.Join(kbc.Dir, "api", kbc.Version, strings.ToLower(kbc.Kind)+"_types.go")
+
+			// Add a new field with feature gate using the utility function
+			newField := `
+	// Experimental field that requires the "experimental-field" feature gate
+	// +feature-gate experimental-field
+	// +optional
+	ExperimentalField *string ` + "`" + `json:"experimentalField,omitempty"` + "`"
+
+			err = pluginutil.InsertCode(
+				typesFile,
+				"Foo *string `json:\"foo,omitempty\"`",
+				newField,
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("regenerating the project to discover new feature gates")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--force",
+				"--make=false",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("verifying the new feature gate was discovered")
+			featureGatesFile := filepath.Join(kbc.Dir, "internal", "featuregates", "featuregates.go")
+			Expect(featureGatesFile).To(BeAnExistingFile())
+			featureGatesContent, err := os.ReadFile(featureGatesFile)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(string(featureGatesContent)).To(ContainSubstring("experimental-field"))
+		})
+
+		It("should build project with feature gates", func() {
+			By("initializing a project with feature gates")
+			err := kbc.Init(
+				"--domain", kbc.Domain,
+				"--with-feature-gates",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("creating API")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--make=false",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("building the project - this should succeed with feature gates")
+			err = kbc.Make("build")
+			Expect(err).NotTo(HaveOccurred())
+
+			By("verifying the binary was created")
+			binaryPath := filepath.Join(kbc.Dir, "bin", "manager")
+			Expect(binaryPath).To(BeAnExistingFile())
+		})
+
+		It("should generate manifests with feature gates", func() {
+			By("initializing a project with feature gates")
+			err := kbc.Init(
+				"--domain", kbc.Domain,
+				"--with-feature-gates",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("creating API")
+			err = kbc.CreateAPI(
+				"--group", kbc.Group,
+				"--version", kbc.Version,
+				"--kind", kbc.Kind,
+				"--resource", "--controller",
+				"--make=false",
+			)
+			Expect(err).NotTo(HaveOccurred())
+
+			By("generating manifests")
+			err = kbc.Make("manifests")
+			Expect(err).NotTo(HaveOccurred())
+
+			By("verifying CRDs were generated")
+			crdFile := filepath.Join(kbc.Dir, "config", "crd", "bases",
+				strings.ToLower(kbc.Group)+"."+kbc.Domain+"_captains.yaml")
+			Expect(crdFile).To(BeAnExistingFile())
+		})
+	})
+})
diff --git a/test/features.sh b/test/features.sh
index f5d48d9a611..420c992c2f3 100755
--- a/test/features.sh
+++ b/test/features.sh
@@ -37,4 +37,7 @@ go test "$(dirname "$0")/e2e/alphagenerate" ${flags:-} -timeout 30m
 header_text "Running Alpha Update Command E2E tests"
 go test "$(dirname "$0")/e2e/alphaupdate" ${flags:-} -timeout 30m
 
+header_text "Running Feature Gates Unit tests"
+go test "$(dirname "$0")/e2e/featuregates" ${flags:-} -timeout 30m
+
 popd >/dev/null