github.com/wagoodman/dive

Dive is fundamentally a standalone CLI tool rather than a Go library you'd import into your projects. It excels at interactive Docker image layer analysis through a TUI interface. The experience is straightforward: install the binary and run `dive <image-name>`. The interface immediately shows layer-by-layer breakdowns with file changes, wasted space calculations, and efficiency scores.

From a DX perspective as a library, there's limited value since it's not designed for programmatic use. The Go code is well-structured internally if you're contributing, but there's no public API documentation for importing it as a package. Error messages are clear when images can't be found or Docker isn't running. The CLI flags are intuitive (`--ci` for CI integration is particularly useful), and the interactive keybindings are discoverable within the interface.

For teams optimizing Docker builds, the CI mode that fails builds based on efficiency thresholds is practical and easy to integrate into pipelines. The tool does exactly what it promises with minimal friction.

Dive is refreshingly straightforward to use - it's a CLI tool, not a library you import, which means zero integration complexity. You simply run `dive <image-name>` and get an interactive TUI that shows layer-by-layer breakdowns of your Docker images. The learning curve is nearly flat: arrow keys navigate layers, tab switches between views, and Ctrl+C exits. I was analyzing images productively within 60 seconds of first launch.

The tool excels at its core use case: identifying bloat and understanding what each layer adds to your image. The efficiency score feature immediately highlights wasted space from duplicate files across layers. Error messages are clear when images don't exist locally, and it gracefully handles both local images and remote registries. The CI mode (`--ci`) with configurable thresholds is particularly useful for automated builds.

Documentation is minimal but sufficient since the tool is simple. GitHub issues show responsive maintainers, though the community is smaller than framework-level projects. Common pitfalls are rare - the main gotcha is remembering this analyzes existing images, not Dockerfiles directly.

Dive is a standalone CLI tool rather than a Go library you'd import into your projects. It provides an interactive terminal UI for exploring Docker image layers, which is invaluable for debugging bloated images and understanding layer composition. The TUI is intuitive with keyboard shortcuts clearly displayed, making it easy to navigate file trees and see which layers added which files.

From a DX perspective, installation is straightforward via binary releases or package managers. The tool requires no configuration to get started—just run 'dive <image>' and you're analyzing layers immediately. The efficiency score feature helps quantify image waste, giving concrete metrics for optimization efforts. However, there's no Go API to embed this functionality into CI/CD pipelines programmatically, which limits automation possibilities.

Error messages are clear when images can't be found or Docker isn't running. The tool handles large images gracefully, though very deep layer stacks can make navigation tedious. Documentation focuses on CLI usage rather than integration scenarios, which is appropriate given its design as a standalone utility.