func isNonInteractive(inv *serpent.Invocation) bool {
    if inv.ParsedFlags().Lookup("yes") != nil {
        if skip, _ := inv.ParsedFlags().GetBool("yes"); skip {
            return true
        }
    }
    return false
}

if workspaceName == "" {
    if isNonInteractive(inv) {
        return xerrors.New("workspace name is required in non-interactive mode; provide it as an argument")
    }
    // existing prompt code...
}

case templateName == "":
    if isNonInteractive(inv) {
        return xerrors.New("template is required in non-interactive mode; use --template flag")
    }
    // existing prompt code...

if len(tvPresets) > 0 && strings.ToLower(presetName) != PresetNone {
    preset, err = resolvePreset(tvPresets, presetName)
    if err != nil {
        if !errors.Is(err, ErrNoPresetFound) {
            return xerrors.Errorf("unable to resolve preset: %w", err)
        }
        // NEW: In non-interactive mode, skip presets instead of prompting
        if isNonInteractive(inv) {
            // No preset found and non-interactive - skip presets
            preset = nil
        } else {
            // Interactive mode - prompt user
            if preset, err = promptPresetSelection(inv, tvPresets); err != nil {
                return xerrors.Errorf("unable to prompt user for preset: %w", err)
            }
        }
    }
    // ... rest of preset handling
}

type ParameterResolver struct {
    // ... existing fields
    nonInteractive bool  // NEW
}

func (pr *ParameterResolver) WithNonInteractive(nonInteractive bool) *ParameterResolver {
    pr.nonInteractive = nonInteractive
    return pr
}

func (pr *ParameterResolver) resolveWithInput(...) ([]codersdk.WorkspaceBuildParameter, error) {
    for _, tvp := range templateVersionParameters {
        p := findWorkspaceBuildParameter(tvp.Name, resolved)
        if p != nil {
            continue
        }

        // Parameter needs resolution
        firstTimeUse := pr.isFirstTimeUse(tvp.Name)
        promptParameterOption := pr.isLastBuildParameterInvalidOption(tvp)

        needsInput := (tvp.Ephemeral && pr.promptEphemeralParameters) ||
            (action == WorkspaceCreate && tvp.Required) ||
            (action == WorkspaceCreate && !tvp.Ephemeral) ||
            (action == WorkspaceUpdate && promptParameterOption) ||
            (action == WorkspaceUpdate && tvp.Mutable && tvp.Required) ||
            (action == WorkspaceUpdate && !tvp.Mutable && firstTimeUse) ||
            (tvp.Mutable && !tvp.Ephemeral && pr.promptRichParameters)

        if needsInput {
            // NEW: In non-interactive mode, use default or fail
            if pr.nonInteractive {
                if tvp.DefaultValue != "" {
                    // Use default value
                    resolved = append(resolved, codersdk.WorkspaceBuildParameter{
                        Name:  tvp.Name,
                        Value: tvp.DefaultValue,
                    })
                } else if tvp.Required {
                    // Required parameter with no default - fail
                    return nil, xerrors.Errorf(
                        "parameter %q is required but has no default value; "+
                        "provide it with --parameter %s=<value>",
                        tvp.Name, tvp.Name)
                }
                // Optional parameter with no default - skip (will use empty/server default)
                continue
            }

            // Interactive mode - prompt as before
            parameterValue, err := cliui.RichParameter(inv, tvp, pr.richParametersDefaults)
            // ... existing code
        }
        // ... rest of existing logic
    }
    return resolved, nil
}

resolver := new(ParameterResolver).
    // ... existing chain
    WithNonInteractive(isNonInteractive(inv))

func SkipPromptOption() serpent.Option {
    return serpent.Option{
        Flag:          skipPromptFlag,
        FlagShorthand: "y",
        Description:   "Run in non-interactive mode. Use default values and fail if required inputs are missing.",
        Value:         serpent.BoolOf(new(bool)),
    }
}

// In prepWorkspaceBuild, modify the ExternalAuth call
err = cliui.ExternalAuth(ctx, inv.Stdout, cliui.ExternalAuthOptions{
    Fetch: func(ctx context.Context) ([]codersdk.TemplateVersionExternalAuth, error) {
        return client.TemplateVersionExternalAuth(ctx, templateVersion.ID)
    },
    NonInteractive: isNonInteractive(inv),  // NEW: pass flag
})

type ExternalAuthOptions struct {
    Fetch          func(ctx context.Context) ([]codersdk.TemplateVersionExternalAuth, error)
    NonInteractive bool  // NEW
}

// In the function body, after fetching auth status:
for _, auth := range auths {
    if !auth.Authenticated && !auth.Optional {
        if o.NonInteractive {
            return xerrors.Errorf("external authentication %q is required but not authenticated; "+
                "authenticate via browser first or ensure the template marks it as optional", auth.DisplayName)
        }
        // ... existing polling/waiting logic
    }
}