# Can No-Mistakes Ask the User for Input on Findings? Implementation Guide

> Learn how to enable user input for findings in no-mistakes. Configure ActionAskUser to pause pipelines and get explicit approval. Implement this guide for better control.

- Repository: [Kun Chen/no-mistakes](https://github.com/kunchenguid/no-mistakes)
- Tags: how-to-guide
- Published: 2026-06-28

---

**Yes.** No-mistakes can pause pipeline execution and prompt the human operator for decisions when a finding's action is set to `ActionAskUser`, creating a gate that requires explicit user approval before proceeding.

The open-source **no-mistakes** repository implements a sophisticated human-in-the-loop workflow that distinguishes between automated fixes and changes requiring human judgment. When a pipeline step produces findings tagged with `"ask-user"`, the executor parks the run, surfaces an awaiting status in the TUI, and generates a prompt for the operator to approve, edit, or skip the proposed change.

## How No-Mistakes Implements User Input Requests

The architecture relies on a constant-action pattern within the finding model. When code analysis detects ambiguous or risky conditions that should not proceed automatically, it assigns the `ActionAskUser` constant to signal that human intervention is required.

### The Finding Model Definition

In [`internal/types/findings.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/types/findings.go), the system defines three possible actions for any finding:

```go
const (
    ActionNoOp    = "no-op"
    ActionAutoFix = "auto-fix"
    ActionAskUser = "ask-user"
)

```

A finding with `Action` set to `ActionAskUser` explicitly triggers the user input workflow. This design ensures that automated steps and human gates share the same data structure, allowing the executor to route findings appropriately based on the action type.

### Detection Logic

The helper function `HasAskUserFindings` scans finding collections to determine if any item requires human review:

```go
// internal/types/findings.go
func HasAskUserFindings(findings Findings) bool {
    for _, item := range findings.Items {
        if item.Action == ActionAskUser {
            return true
        }
    }
    return false
}

```

The pipeline executor invokes this function after every step to decide whether to auto-fix or pause for approval.

## The Ask-User Pipeline Flow

When the executor detects ask-user findings, it transitions the run into an *awaiting-agent* state. This flow involves three core components: the executor's pause logic, the TUI rendering layer, and the prompt generation system.

### Executor Pause Logic

In [`internal/pipeline/executor.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/pipeline/executor.go) (approximately lines 340-350), the executor checks findings before proceeding:

```go
if !outcome.NeedsApproval && !hasAskUserFindingsJSON(outcome.Findings) {
    // Safe to auto-fix / continue
    ...
} else {
    // Mark the run as awaiting-agent so the UI shows a prompt.
    db.SetRunAwaitingAgent(runID, time.Now())
    // The agent driver will later ask the user.
}

```

If any `ask-user` findings exist, the call to `db.SetRunAwaitingAgent` parks the run immediately. The executor does not apply any automatic fixes, ensuring that potentially risky changes remain pending until a human validates them.

### UI Rendering

The TUI aggregates findings by action type in [`internal/cli/axi_render.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/cli/axi_render.go) within the `findingsTally` function:

```go
case types.ActionAskUser:
    awaiting++

```

This tally appears in the run object as `"<n> awaiting"`, providing immediate visibility into how many decisions the operator must resolve. Additionally, the `runObjectFieldWithKey` function renders an `awaiting_agent` field showing the human-readable duration since the run was parked.

### Prompt Generation

When the executor reaches a gate containing ask-user findings, the driver in [`internal/cli/axi_drive.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/cli/axi_drive.go) (around line 470) constructs a human-readable instruction:

```

CI checks passed - the PR is ready. Ask the user to review and merge it.

```

This prompt appears when the user runs `no-mistakes axi status`, followed by a CLI instruction to respond:

```bash
no-mistakes axi respond --run <run-id> <decision>

```

The skill body defined in [`internal/skill/skill.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/skill/skill.go) reinforces this by including a gate note that explicitly states, "Ask how they want to proceed," ensuring that AI agents interacting with the system recognize the requirement for human input.

## Practical Implementation Example

To request user input from within a custom pipeline step, create a finding with the `ActionAskUser` action:

```go
package main

import (
    "github.com/kunchenguid/no-mistakes/internal/types"
)

func main() {
    // Simulate a pipeline step that discovers a risky change.
    f := types.Finding{
        ID:          "f-001",
        Severity:    "error",
        File:        "cmd/main.go",
        Line:        42,
        Description: "Potential nil-pointer dereference",
        Action:      types.ActionAskUser, // Triggers user prompt
    }

    // The step returns its findings (normally via the pipeline framework):
    findings := types.Findings{
        Items: []types.Finding{f},
        Summary: "1 finding requiring user review",
    }

    // The executor will now park the run and the CLI will show:
    //   awaiting: 1
    // The operator can answer:
    //   $ no-mistakes axi respond --run <run-id> approve
}

```

When the finding is returned to the pipeline executor, the system automatically pauses execution and surfaces the waiting status in the CLI.

## Responding to User Input Requests

Once a run is parked with `awaiting_agent` status, the operator interacts with the system through two primary commands:

1. **Check status**: `no-mistakes axi status` displays the parked run with the `awaiting` tally and duration
2. **Submit decision**: `no-mistakes axi respond --run <id> approve|edit|skip`

The [`internal/e2e/journey_test.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/e2e/journey_test.go) file contains end-to-end tests verifying that runs with `ActionAskUser` correctly end in a parked state and that user responses properly ungate the pipeline.

## Summary

- **Yes**, no-mistakes supports requesting user input on findings through the `ActionAskUser` constant defined in [`internal/types/findings.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/types/findings.go).
- The **pipeline executor** detects ask-user findings via `HasAskUserFindings` and parks the run using `SetRunAwaitingAgent`.
- The **TUI** renders an awaiting tally and `awaiting_agent` timestamp so operators know exactly which decisions are pending.
- Users resolve gates via `no-mistakes axi respond --run <id> <decision>`, allowing explicit approval of risky or ambiguous changes before the pipeline continues.

## Frequently Asked Questions

### How does no-mistakes distinguish between auto-fixable and human-required findings?

No-mistakes uses the `Action` field in the `Finding` struct. When set to `ActionAutoFix` in [`internal/types/findings.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/types/findings.go), the executor applies changes automatically. When set to `ActionAskUser`, the executor invokes `db.SetRunAwaitingAgent` and pauses execution, routing the decision to the human operator instead.

### Can I customize the prompt shown to users when asking for input?

Yes. The prompt generation logic in [`internal/cli/axi_drive.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/cli/axi_drive.go) constructs human-readable instructions based on the finding context. While the default message explains what needs review, you can extend the skill body in [`internal/skill/skill.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/skill/skill.go) to include specific gate notes that provide additional context about why the finding requires human judgment.

### What happens if multiple findings require user input in a single run?

The `findingsTally` function in [`internal/cli/axi_render.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/cli/axi_render.go) aggregates all ask-user findings into a single count. The run remains parked until the user responds with `no-mistakes axi respond`, at which point the decision applies to the specific run state. The system treats multiple awaiting findings as a single gate that requires resolution before the pipeline can proceed.

### Is the ask-user workflow secure for production CI/CD pipelines?

Yes. Because the executor in [`internal/pipeline/executor.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/pipeline/executor.go) explicitly checks `HasAskUserFindings` before applying any fixes, there is no risk of accidental auto-execution for findings marked with `ActionAskUser`. The run state transitions to `awaiting_agent` and remains immutable until an authorized operator explicitly responds, ensuring that sensitive or risky changes cannot bypass human review.