Is There a Roadmap for no-mistakes? Future Development Plans Explained

While the no-mistakes repository does not contain a dedicated roadmap file, the project's future direction is clearly encoded in its architecture, test suite, and build configuration.

no-mistakes is a Go-based CLI that intercepts git push calls to run an AI-driven validation pipeline before forwarding changes to the remote. Although maintainers have not published a formal roadmap document, the codebase reveals strategic priorities through its design patterns, extensive test coverage, and development tooling choices.

Where the Roadmap Lives: Inferring Direction from Source Code

Core Architecture in cmd/no-mistakes/main.go

The entry point in cmd/no-mistakes/main.go establishes the high-level execution flow: initialize, validate, and push. The pipeline orchestration implemented under internal/pipeline/ and the lifecycle management in internal/daemon/ indicate a focus on robust, stateful execution environments. These structural choices suggest continued investment in reliable worktree management and disposable execution contexts.

Feature-Focused Tests Across internal/agent/

The test suite reveals active development areas through comprehensive coverage. Files in internal/agent/ test multiple AI providers including Claude, Codex, Opencode, Pi, and Copilot, alongside generic acp adapters. Meanwhile, internal/git/ contains specific tests for GitLab integration and bare-repository handling, signaling ongoing work to harden SCM backend resilience across different hosting platforms.

Build Scripts and Documentation Targets

The Makefile exposes future-oriented capabilities through specific targets. The make demo command regenerates GIF and MP4 visual assets, while make docs builds the Astro documentation site. Additionally, make e2e-record captures real-agent fixtures, demonstrating a commitment to keeping end-to-end workflows synchronized with external AI services.

Inferred Development Priorities

Agent Integration Expansion

Current support spans Claude, Codex, Opencode, Pi, and Copilot through the acp adapter framework. Future enhancements likely include new adapters (e.g., Gemini), improved fallback logic when primary agents fail, and reduced warm-up latency for model initialization.

Pipeline Extensibility

The current fixed pipeline—review → test → docs → lint → push → PR—resides in internal/pipeline/. Planned improvements appear to include plugin hooks for custom validation steps, community-contributed agent integration, and a programmable DSL allowing teams to reorder or skip pipeline stages.

Security and Trust Hardening

Security features currently fetch trusted configuration from the default branch with allow_repo_commands defaulting to false. Expected improvements include hardened sandboxing for agent-generated code, comprehensive audit logs for privileged commands, and per-repository policy overrides for enterprise deployments.

Daemon Robustness

The singleton lock and graceful shutdown mechanisms in internal/daemon/ will likely expand to support hot-reloading of configuration without restart, improved cross-platform resilience (particularly on Windows), and health metrics export for monitoring integrations.

User Experience Improvements

Current UX includes the interactive TUI (no-mistakes), non-interactive mode (no-mistakes -y), and Git proxy integration (git push no-mistakes). Future work likely targets refined UI ergonomics, a VS Code extension for inline validation, and richer visual diffs for AI-generated findings.

Documentation and Tooling

With documentation generated via Astro and demos produced via vhs/ffmpeg, the project aims to expand multilingual documentation, automated changelog generation, and CI status badges for downstream project integration.

Testing and CI Infrastructure

Beyond unit tests and e2e tests gated behind the e2e build tag, the project plans increased coverage for edge-case git operations, fuzz testing for agent output validation, and automated regression detection for third-party API changes. The test-driven development approach emphasized in AGENTS.md ensures future changes maintain existing safety guarantees.

Current Capabilities and Usage Examples

Initialize the validation gate for your repository:

# Initialise the gate (once per repository)

no-mistakes init

# Push a branch through the gate

git push no-mistakes my-feature

Attach to running pipelines or run non-interactive mode:

# Open the TUI to resolve findings

no-mistakes

# Auto-accept safe fixes and skip manual steps

no-mistakes -y

Invoke agents directly through the unified interface:

# Use the skill with Claude Code

axi run /no-mistakes "refactor the function foo() to be pure"

# Works with any configured agent, e.g., Codex:

axi run /no-mistakes "add unit tests for bar()"

The following hypothetical example illustrates the planned plugin API for custom pipeline steps:

// internal/pipeline/steps/custom.go
package steps

import "github.com/kunchenguid/no-mistakes/internal/pipeline"

func RegisterMyStep(p *pipeline.Pipeline) {
    p.AddStep(pipeline.Step{
        Name: "my-custom-step",
        Run: func(ctx pipeline.StepContext) error {
            // custom validation logic here
            return nil
        },
    })
}

Summary

• no-mistakes does not publish a formal roadmap document, but strategic direction is evident in the codebase architecture.
• Development priorities center on expanding AI agent support, improving pipeline extensibility, and hardening security guarantees.
• Key files revealing future direction include cmd/no-mistakes/main.go, internal/pipeline/, internal/daemon/, and AGENTS.md.
• Build targets like make e2e-record and make docs indicate sustained investment in developer experience and documentation.
• All future changes are expected to follow the rigorous testing conventions established in the existing test suite.

Frequently Asked Questions

Does no-mistakes have a formal roadmap document?

No, the repository does not contain a dedicated roadmap file. However, the project's future direction can be inferred from the architecture in cmd/no-mistakes/main.go, the comprehensive test suite in internal/agent/ and internal/git/, and the build targets defined in the Makefile.

How does the project ensure new features don't break existing functionality?

The maintainers follow test-driven development with extensive unit tests and e2e tests gated behind the e2e build tag. The testing conventions documented in AGENTS.md require that all new functionality be accompanied by regression tests, ensuring that safety guarantees remain intact through iterative development.

What AI agents are currently supported?

The codebase includes tests and adapters for Claude, Codex, Opencode, Pi, Copilot, and generic acp adapters. The modular architecture in internal/agent/ suggests straightforward addition of future providers like Gemini or custom enterprise models.

How can I prepare for upcoming pipeline changes?

Monitor the internal/pipeline/ directory for structural changes and review AGENTS.md for evolving testing conventions. The project plans to introduce plugin hooks and a programmable DSL for custom steps, so keeping custom validations in separate packages will ease migration to the forthcoming extensibility API.

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