How New Features Are Proposed and Implemented in no-mistakes

New features in no-mistakes must pass through a mandatory gate-first workflow where an interactive wizard automates branch creation, commits, and pushes through a validation pipeline before automatically opening a pull request against the upstream repository.

The kunchenguid/no-mistakes repository enforces a strict automated contribution process. Every new feature proposed and implemented in no-mistakes must originate from the gate workflow, ensuring consistent code quality through deterministic validation steps defined in CONTRIBUTING.md.

The Gate-First Development Workflow

The contribution process is fully automated through a command-line wizard. According to CONTRIBUTING.md lines 3-24, “All pull requests to this repository must be raised through no‑mistakes”.

Fork and Clone the Repository

Begin by forking the repository on GitHub and cloning your local copy:

git clone git@github.com:YOURUSER/no-mistakes.git
cd no-mistakes

Initialize the Gate

Run the initialization command to configure the no-mistakes remote:

no-mistakes init --fork-url git@github.com:YOURUSER/no-mistakes.git

This sets up a remote called “no-mistakes” that serves as the entry point for the validation pipeline.

Run the Wizard

The wizard implemented in internal/wizard/wizard.go (lines 20-44) handles branch creation and commit message generation. Execute the wizard in auto-advance mode:

no-mistakes run --auto-advance

Alternatively, run interactively to manually control each step:

no-mistakes

The interactive flow prompts for:

• Branch creation (or accept the agent-suggested name)
• Commit message composition (or accept the suggestion)
• Final confirmation before pushing to the gate

Automated Pipeline Execution

Once the wizard pushes changes to the gate remote, the pipeline runs automatically. The process includes intent analysis, rebase, review, test, and lint stages.

The Makefile provides the targets (make lint, make test, make e2e) that the pipeline executes. When all stages pass successfully, the wizard automatically opens a pull request against the upstream repository and attaches the deterministic signature required by the CI check.

Wizard Implementation and Agent Logic

The core orchestration logic resides in internal/wizard/wizard.go. This file implements the interactive and non-interactive steps that create a branch, commit changes, and push through the gate.

The wizard suggests branch names and commit messages via an integrated agent, then creates the branch, commits the changes, and pushes to the gate remote. This ensures that all metadata follows the repository's naming conventions before entering the pipeline.

Skill Definitions and Command Vocabulary

In internal/skill/skill.go (lines 17-33), the canonical skill description defines the command vocabulary that agents use to drive the pipeline. This abstraction ensures that the same logic applied during local development is consistently executed when the tool is installed by end users.

The skill definitions cover the command set used for intent parsing, rebase operations, and validation checks, maintaining uniformity across different execution environments.

CI Enforcement and Pull Request Requirements

All pull requests that do not originate from this flow are rejected by the “Require no-mistakes” GitHub Action. This enforcement mechanism guarantees that every contribution has passed the same automated review and testing as the core tool itself.

The deterministic signature attached to each PR proves that the changes passed through the gate pipeline, preventing manual bypass of quality checks.

Summary

• Gate-first workflow: All new features must pass through the no-mistakes gate before a pull request is opened.
• Wizard automation: The tool in internal/wizard/wizard.go handles branch creation, commit messages, and pushes via an agent-driven process.
• Pipeline validation: Automated stages include intent analysis, rebase, review, testing, and linting before PR creation.
• CI enforcement: The “Require no-mistakes” GitHub Action rejects any PRs not originating from the gate workflow.
• Skill definitions: internal/skill/skill.go ensures consistent command vocabulary across local and distributed environments.

Frequently Asked Questions

What happens if I try to open a pull request without using the no-mistakes wizard?

The “Require no-mistakes” GitHub Action automatically rejects any pull request that does not include the deterministic signature generated by the gate pipeline. All contributions must originate from the wizard workflow documented in CONTRIBUTING.md.

Can I manually control the branch name and commit message during the wizard flow?

Yes. While the wizard supports --auto-advance mode for fully automated suggestions, running no-mistakes interactively allows you to override the agent-suggested branch names and commit messages at each step before confirming the push.

What specific checks does the pipeline run before opening a PR?

The pipeline executes intent analysis, rebase operations, code review, unit tests, and linting as defined in the Makefile targets. These stages ensure that changes meet the repository's quality standards before the wizard automatically opens the pull request.

Where is the gate remote configured in the codebase?

The gate remote configuration is established when you run no-mistakes init --fork-url, which sets up a remote called “no-mistakes” pointing to your fork. The wizard then pushes branches to this remote to trigger the pipeline, as implemented in internal/wizard/wizard.go lines 20-44.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}