github.com/air-verse/air

Air has become my go-to for Go development hot-reloading. The setup is genuinely straightforward—run `air init` to generate a `.air.toml`, tweak a few paths if needed, and you're watching files rebuild on save. The default configuration is sensible for most Go projects, catching `.go` file changes and restarting your binary automatically. It handles both web servers and CLI tools well, which is more versatile than many alternatives.

The configuration file is well-documented inline with comments explaining each option, though the official docs are sparse beyond the README. You'll appreciate options like `exclude_dir` for ignoring vendor folders and `delay` for debouncing rapid file changes. Build errors appear in your terminal clearly, preserving your original compiler output.

The main friction point is cryptic behavior when your build process hangs or when Air's own process management gets confused—you'll occasionally need to kill orphaned processes manually. The `.air.toml` schema isn't exposed as a typed config in Go (it's a CLI tool, after all), so configuration errors only surface at runtime. Still, for day-to-day development, it stays out of your way and just works.

Air has become my go-to for hot-reloading during Go development. Installation is straightforward (go install or binary), and the default config works immediately for most projects. Running `air` in your project root just works - it watches .go files and rebuilds on save with clear console output showing build status and errors. The colored output makes it easy to distinguish between build failures and runtime issues at a glance.

The `.air.toml` configuration is well-documented with sensible defaults. I appreciate the granular control over what triggers rebuilds (file extensions, directories to watch/ignore) and build commands. Custom build arguments, environment variables, and post-build hooks cover most real-world scenarios. Error messages are clear when Air can't find your binary or when the config is malformed.

The main limitation is IDE integration - you're relying on Air's output in a terminal rather than native IDE feedback. Occasionally, file watchers can get confused with rapid successive saves, requiring a restart. Documentation could use more examples for Docker development workflows, which require specific configuration tweaks.

Air is a live-reload development tool that watches your Go files and automatically rebuilds/restarts your application. In daily use, it's refreshingly lightweight and stays out of your way. The configuration via .air.toml is straightforward, with sensible defaults that work for most Go projects immediately. It handles file watching reliably across different OSes and doesn't introduce noticeable lag between code changes and restart cycles.

The tool integrates well with development workflows - it properly terminates processes, handles signal forwarding, and provides clear console output about what it's doing. Resource usage is minimal, which matters when running multiple services locally. The exclude patterns and delay configurations give you control over build triggers without overwhelming complexity.

One practical caveat: this is strictly a development tool, not a production process manager. It doesn't have connection draining, graceful shutdown hooks, or any of the sophisticated restart logic you'd need in production. That's by design, but worth understanding. The documentation could be clearer about timeout behavior when your app hangs during startup.