# Programming Languages Used in the no-mistakes Repository: A Complete Breakdown

> Discover the programming languages in the no-mistakes repository. Primarily Go, with Shell, YAML, Markdown, and JSON support. Get a complete breakdown.

- Repository: [Kun Chen/no-mistakes](https://github.com/kunchenguid/no-mistakes)
- Tags: deep-dive
- Published: 2026-07-11

---

**The no-mistakes repository is primarily written in Go, with supporting Shell scripts, YAML configurations, Markdown documentation, and JSON metadata files.**

The `no-mistakes` project is a Go-centric codebase that implements a CLI tool and daemon architecture for safe Git operations. Understanding the programming languages used in the no-mistakes repository helps developers contribute effectively and integrate the tooling into their workflows. The codebase follows a clean separation between core application logic written in Go and auxiliary configuration files that support deployment and documentation.

## Primary Language: Go

The **Go programming language** powers every aspect of the application's core functionality, from the CLI entrypoint to the daemon process management and pipeline logic.

### Core Application Architecture

According to the source code in `kunchenguid/no-mistakes`, the repository structure follows standard Go project conventions with clear separation of concerns:

- **CLI entrypoint** – [`cmd/no-mistakes/main.go`](https://github.com/kunchenguid/no-mistakes/blob/main/cmd/no-mistakes/main.go) contains the `main` package that bootstraps the application
- **Daemon implementation** – [`internal/daemon/lock.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/daemon/lock.go) handles singleton process locking using OS-level file locks
- **Pipeline logic** – [`internal/pipeline/steps/forcepush.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/pipeline/steps/forcepush.go) implements safe force-push handling
- **Command handling** – [`internal/cli/root.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/cli/root.go) defines the command structure and flag parsing

### Key Implementation Examples

The daemon utilizes Go's concurrency primitives and system-level operations to ensure only one instance runs per user. In [`internal/daemon/lock.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/daemon/lock.go), the `acquireSingletonLock` function demonstrates this pattern:

```go
func acquireSingletonLock(ctx context.Context, lockPath string) (*os.File, error) {
    f, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0o600)
    if err != nil { return nil, err }
    // Acquire exclusive OS lock
    if err = syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {
        f.Close()
        return nil, err
    }
    return f, nil
}

```

The CLI entry point in [`cmd/no-mistakes/main.go`](https://github.com/kunchenguid/no-mistakes/blob/main/cmd/no-mistakes/main.go) follows the standard Go command pattern:

```go
package main

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

func main() {
    no_mistakes.Execute()
}

```

## Supporting Languages and File Types

While Go dominates the source code, the repository leverages several auxiliary formats for configuration, automation, and documentation.

### Shell Scripts for Build Automation

**Bash/Shell** scripts handle cross-platform builds and continuous integration tasks. The `Makefile` contains recipes for compiling binaries across different operating systems, while platform-specific transport implementations in [`internal/ipc/transport_unix.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/ipc/transport_unix.go) and [`internal/ipc/transport_windows.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/ipc/transport_windows.go) use `exec.CommandContext` for system-level process management.

### Configuration and Documentation Formats

The repository uses **YAML** for structured configuration and **Markdown** for documentation:

- **YAML** – [`.no-mistakes.yaml`](https://github.com/kunchenguid/no-mistakes/blob/main/.no-mistakes.yaml) defines repository-wide settings consumed by the daemon, while CI pipeline configurations use YAML for workflow definitions
- **Markdown** – [`README.md`](https://github.com/kunchenguid/no-mistakes/blob/main/README.md) provides high-level project overview, [`AGENTS.md`](https://github.com/kunchenguid/no-mistakes/blob/main/AGENTS.md) documents agent behavior, and [`docs/src/content/docs/guides/agents.md`](https://github.com/kunchenguid/no-mistakes/blob/main/docs/src/content/docs/guides/agents.md) contains extended knowledge-base articles
- **JSON** – [`opencode.json`](https://github.com/kunchenguid/no-mistakes/blob/main/opencode.json) and [`.release-please-manifest.json`](https://github.com/kunchenguid/no-mistakes/blob/main/.release-please-manifest.json) manage metadata for release automation and test fixtures

## Repository Language Distribution

The programming languages used in the no-mistakes repository break down as follows:

- **Go** – Application source, unit tests, and generated tooling (primary language)
- **Shell** – Build scripts and CI helpers
- **YAML** – Configuration files for the daemon and documentation site
- **Markdown** – Documentation and knowledge-base content
- **JSON** – Release manifests and test fixtures
- **Binary assets** – Demo media files (`demo.mp4`, `demo.gif`) for documentation purposes

## Summary

- The **no-mistakes repository** is a **Go-first codebase** with all core functionality—including the CLI, daemon, and pipeline logic—implemented in Go.
- **Shell scripts** in the `Makefile` and transport files handle cross-platform build automation and CI tasks.
- **YAML files** provide configuration for the daemon and documentation infrastructure, while **Markdown** powers the comprehensive documentation system.
- Key files include [`cmd/no-mistakes/main.go`](https://github.com/kunchenguid/no-mistakes/blob/main/cmd/no-mistakes/main.go) for the entry point, [`internal/daemon/lock.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/daemon/lock.go) for process locking, and [`.no-mistakes.yaml`](https://github.com/kunchenguid/no-mistakes/blob/main/.no-mistakes.yaml) for configuration.

## Frequently Asked Questions

### Is the no-mistakes repository open to contributions in other programming languages?

The no-mistakes project maintains a strict Go-only policy for core functionality to ensure consistency and leverage Go's strong concurrency model for the daemon architecture. Contributors should write all feature code in Go, though Shell scripts for build automation and YAML for configuration are acceptable for supporting infrastructure.

### What Go version does the no-mistakes repository require?

While the specific Go version isn't explicitly stated in the provided analysis, the code utilizes modern Go features including `exec.CommandContext` for process management and `syscall.Flock` for file locking, indicating compatibility with recent Go releases that support these standard library patterns.

### Why was Go chosen as the primary language for the no-mistakes project?

The architecture requires reliable **singleton daemon management** and safe **concurrent pipeline execution**, which Go handles efficiently through goroutines and OS-level primitives like `syscall.Flock`. The language's static typing and cross-compilation capabilities also support the project's distribution as a standalone CLI tool across multiple platforms.

### Where can I find examples of the Go implementation in the no-mistakes repository?

Examine [`cmd/no-mistakes/main.go`](https://github.com/kunchenguid/no-mistakes/blob/main/cmd/no-mistakes/main.go) for the CLI entry point implementation, [`internal/daemon/lock.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/daemon/lock.go) for the singleton lock mechanism using `acquireSingletonLock`, and [`internal/pipeline/steps/forcepush.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/pipeline/steps/forcepush.go) for the safe force-push logic that demonstrates the project's error handling patterns.