Data as of Aug 25, 2026 · Based on 337 AI responses from ChatGPT Search and Google AI Mode · See how Parse measures this
The ideal framework depends on your language. For Go, use Cobra and Viper to enable static binary distribution and configuration management. For high-performance needs in Rust, use Clap. For Python, use 
Brands AI recommends here
Named in 63% of answers
Named in 59% of answers
Named in 53% of answers
Highly recommended for production-grade Python CLI tools. It is flexible and composable, but keep in mind that distributing Python apps can be complex without tools like PyInstaller.
Named in 32% of answers
Source | Citation share |
|---|---|
 GitHub - shadawck/awesome-cli-frameworks: Collection of tools to build beautiful command line interface in different languages · GitHubhttps://github.com/shadawck/awesome-cli-frameworks | 2.9% |
 14 great tips to make amazing CLI applications - DEV Communityhttps://dev.to/wesen/14-great-tips-to-make-amazing-cli-applications-3gp3 | 2.6% |
 Command Line Interface Guidelineshttps://clig.dev/ | 2.4% |
 Structuring a CLI. I love a good CLI, and I like writing… | by Dennis Verweij | Pon.Tech.Talk | Mediumhttps://medium.com/pon-tech-talk/structuring-a-cli-22e2492717de | 2.0% |
 CLI Design Best Practices – Cody A. Rayhttps://codyaray.com/2020/07/cli-design-best-practices | 1.6% |
Mediumhttps://medium.com/jit-team/guidelines-for-creating-your-own-cli-tool-c95d4af62919 | 1.6% |
Crafting a Useful & Extensible (Company) CLI | by David Freilichhttps://medium.com/appsflyerengineering/crafting-a-useful-extensible-toolchain-68220eee1b2 | 1.4% |
 Building CLI Tools: Frameworks and Best Practices — DevTools Guidehttps://www.devtoolsguide.com/cli-development-frameworks/ | 1.4% |
 Elevate developer experiences with CLI design guidelineshttps://www.thoughtworks.com/en-us/insights/blog/engineering-effectiveness/elevate-developer-experiences-cli-design-guidelines | 1.4% |
 The CLI Framework Developers Love | Cobra: A Commander for Modern CLI Appshttps://cobra.dev/ | 1.2% |
Building and managing a consistent, company-wide suite of CLI tools requires treating your terminal interfaces with the same product discipline as your customer-facing APIs or web apps. Without a unified framework, you end up with a sprawling mess of shell scripts, mismatched flag conventions (`-v` meaning "verbose"…
Building and managing a consistent, company-wide suite of CLI tools requires treating your terminal interfaces with the same product discipline as your customer-facing APIs or web apps. Without a unified framework, you end up with a sprawling mess of shell scripts, mismatched flag conventions (-v meaning "verbose" in one tool and "version" in another), and broken distribution pipelines.
A production-grade framework for an internal CLI ecosystem relies on four fundamental pillars: Design Standards, Core Technical Architecture, Distribution & Updates , and Governance & Lifecycle.
Consistency starts with a strict contract on how your tools look, feel, and behave. Adopt or fork an open standard like Command Line Interface Guidelines and codify internal rules:
mycompany k8s-deploy or structured namespaces like mycompany service deploy).--debug, --verbose, --quiet ). Force machine-readable output options (--output json, --output yaml ) on every tool that returns data so developers can easily pipe commands into jq or other scripts.0 for success, 1 for general errors, 2 for usage/syntax errors, 3 for authentication/authorization failures).NO_COLOR environment variables automatically and degrades gracefully in CI/CD environments (no progress bars or ANSI escape sequences when piped).Do not let engineers write argument parsing from scratch. Standardize the underlying libraries by language so that help menus, auto-completion, and flag validation behave identically across teams:
The "Super-CLI" vs. Distributed Binaries Pattern:
Decide whether you want a single monolithic binary (e.g., acme-cli login, acme-cli deploy ) or a unified wrapper plugin model (e.g., acme acting as a manager that dynamically loads acme-deploy, acme-db plugins).
kubectl or git).A great tool is useless if developers are running v1.2 when v4.0 is required. Automate distribution out of developer silos:
curl ... | sh ) or leverage Homebrew via a custom internal tap (brew tap mycompany/tools).mycompany-cli update ). The CLI should periodically check the registry in the background and gently notify users when a newer stable version is available.To prevent tool sprawl (where every team invents their own script), treat your internal CLI ecosystem as a product managed by a Platform Engineering team:
If you'd like to tailor this further, tell me:
I can help draft a concrete project directory structure or a starter template blueprint for your setup.
A good way to think about this is **“CLI platform as a product,” not “a collection of scripts.”** The goal is that every company CLI feels like it came from the same ecosystem, while individual teams can still own domain-specific commands. ## A practical framework I’d structure it around **five layers**:
A good way to think about this is “CLI platform as a product,” not “a collection of scripts.” The goal is that every company CLI feels like it came from the same ecosystem, while individual teams can still own domain-specific commands.
I’d structure it around five layers:
Before choosing a framework, define the things users should never have to relearn.
For example:
company <domain> <resource> <action>
company deploy service api
company env create staging
company db migrate
company logs service api
Standardize:
--help, --versionThis is arguably more important than the underlying CLI library. Cobra's enterprise guidance, for example, explicitly recommends consistent command organization, flag naming, help output, and shallow command hierarchies.
A useful rule is:
Anything users experience should be standardized; anything developers implement should remain flexible unless standardization has a clear payoff.
If you're primarily a Go shop, Cobra is a very reasonable foundation. It provides subcommands, flags, completion, help generation, aliases, and nested command structures, and is already used by projects such as Kubernetes, Docker, and GitHub CLI.
I'd create something like:
company-cli/
├── cmd/
├── internal/
│ ├── auth/
│ ├── config/
│ ├── output/
│ ├── http/
│ ├── errors/
│ ├── telemetry/
│ └── confirmation/
└── plugins/
Then provide a small internal SDK:
companycli.NewCommand(...)
companycli.NewClient(...)
companycli.JSONOutput(...)
companycli.RequireAuth(...)
companycli.RequireConfirmation(...)
companycli.StandardError(...)
Individual teams shouldn't reinvent authentication, API clients, output formatting, telemetry, retries, or configuration.
For larger CLIs, Cobra's own guidance recommends modular command packages rather than putting everything in one cmd package.
I'd distinguish between:
One binary
company deploy ...
company infra ...
company secrets ...
company access ...
and multiple binaries sharing the same platform:
company
company-admin
company-dev
company-security
For most organizations, I prefer one primary developer CLI with domain-owned command groups until it becomes unwieldy.
Think of it like git: teams own different areas, but users experience one coherent interface.
The organizational model can look like:
| Area | Owner | Commands |
|---|---|---|
| Platform | Platform Eng | company env, company deploy |
| Data | Data Platform | company db, company warehouse |
| Security | Security | company secrets, company access |
| Developer Experience | DevEx | company init, company doctor |
Every command has a clearly designated owner.
A beautiful CLI that takes 20 minutes to install won't become the company standard.
You want:
install once
↓
company CLI
↓
automatic/current version
↓
standard authentication
↓
discoverable commands
For polyglot development environments, something like mise can also be useful for pinning development tools and tasks per repository; it supports declaring tools and environment configuration in a checked-in mise.toml.
I'd make installation boring:
brew install company/tap/company
or an equivalent package mechanism, with:
This is where the CLI becomes much more valuable than a standardized collection of commands.
For example:
company service create payments-api
could establish:
repository
CI pipeline
deployment config
IAM
secrets
logging
metrics
alerts
ownership metadata
documentation
The developer doesn't need to know how all those systems work.
This is the internal developer platform / golden-path model: encode the organization's preferred practices into self-service workflows rather than expecting engineers to remember a collection of procedures. AWS's current guidance specifically describes golden paths as a fundamental capability of an internal developer platform, combining best practices with governance while hiding underlying complexity.
The important nuance is:
Opinionated by default, permissive by exception. Don't make the CLI a bureaucratic gatekeeper. Make the standard path so convenient that people voluntarily use it.
Create a lightweight CLI Platform Council or assign this responsibility to the Developer Platform team.
For every CLI:
Name
Purpose
Owner
Repository
Supported platforms
Authentication mechanism
Dependencies
Data/API permissions
Versioning policy
Support tier
Deprecation date
Then classify tools:
Most importantly, don't let the central platform team own every command. They should own the framework and user experience; domain teams should own domain behavior.
I'd aim for something roughly like:
┌─────────────────────┐
│ Company CLI │
│ UX + command tree │
└──────────┬──────────┘
│
┌──────────────┼──────────────┐
│ │ │
Platform Data Security
commands commands commands
│ │ │
└──────────────┼──────────────┘
│
Shared CLI SDK
┌──────────────┼──────────────┐
│ │ │
Auth Config Output
HTTP Errors Telemetry
│
Internal APIs / IDP
The CLI should be a thin interface over well-defined platform APIs, rather than becoming the place where all the business logic lives.
That gives you a much healthier separation:
CLI → API/workflow → platform service → infrastructure
rather than:
CLI → 47 shell scripts → kubectl/aws/terraform/etc.
I'd be quite strict about:
And I'd be relatively permissive about:
Don't measure success by “how many CLI tools did we standardize?”
Measure things like:
That turns the CLI from an IT standardization exercise into a developer-experience product.
My default stack would be:
Go + Cobra → shared internal CLI SDK → one company binary → domain-owned command groups → signed cross-platform releases → centralized auth/config/output → API-first backend → golden-path workflows.
That's a fairly conservative architecture, but it scales nicely and aligns with the broader platform-engineering principle that the platform should provide a small number of well-maintained, self-service paths rather than simply accumulating more tooling.
Most importantly, don't let the central platform team own every command. They should own the framework and user experience; domain teams should own domain behavior.
I'd aim for something roughly like:
┌─────────────────────┐
│ Company CLI │
│ UX + command tree │
└──────────┬──────────┘
│
┌──────────────┼──────────────┐
│ │ │
Platform Data Security
commands commands commands
│ │ │
└──────────────┼──────────────┘
│
Shared CLI SDK
┌──────────────┼──────────────┐
│ │ │
Auth Config Output
HTTP Errors Telemetry
│
Internal APIs / IDP
The CLI should be a thin interface over well-defined platform APIs, rather than becoming the place where all the business logic lives.
That gives you a much healthier separation:
CLI → API/workflow → platform service → infrastructure
rather than:
CLI → 47 shell scripts → kubectl/aws/terraform/etc.
I'd be quite strict about:
And I'd be relatively permissive about:
Don't measure success by “how many CLI tools did we standardize?”
Measure things like:
That turns the CLI from an IT standardization exercise into a developer-experience product.
My default stack would be:
Go + Cobra → shared internal CLI SDK → one company binary → domain-owned command groups → signed cross-platform releases → centralized auth/config/output → API-first backend → golden-path workflows.
Building a consistent, company-wide Command Line Interface (CLI) ecosystem requires treating your internal tools like products rather than quick-and-dirty scripts. A solid framework combines the right technical stack with strong governance, distribution, and developer experience…
Building a consistent, company-wide Command Line Interface (CLI) ecosystem requires treating your internal tools like products rather than quick-and-dirty scripts. A solid framework combines the right technical stack with strong governance, distribution, and developer experience (DevEx).
Pick a primary language that matches your internal engineering stack (usually Go, TypeScript/Node.js, or Python) and enforce a standardized framework per language to guarantee uniform UX (help menus, flags, colors, and exit codes).
A company-wide CLI suite should feel like it was built by a single team. Enforce a shared style guide covering:
mycompany cluster create --region us-east).--output json or --output yaml for CI/CD pipeline integration.--verbose, --debug , and --silent , and bake in anonymous usage telemetry (if compliant with company policy) to see which tools/commands are actually driving value.Manual curl | bash scripts or copying binaries around leads to fragmentation and broken workflows. Centralize how tools are delivered to developer machines and CI agents:
Without a clear owner, internal tools become abandonedware.
acme-cli auth, acme-cli k8s ) or a namespace of independent binaries (e.g., acme-auth, acme-k8s ). A single root CLI with dynamic plugin loading (like kubectl or gh extensions) offers the best balance of unified UX and decoupled team deployments.Would you like to explore choosing a specific language/framework combo (like Go + Cobra) or discuss how to handle authentication and credential management across these internal tools?
A good way to think about this is **“CLI platform,” not “a collection of scripts.”** The goal is to standardize the user experience, lifecycle, security, distribution, and observability while still letting individual teams own domain-specific commands. ## A practical company-wide framework I’d use a **thin internal…
A good way to think about this is “CLI platform,” not “a collection of scripts.” The goal is to standardize the user experience, lifecycle, security, distribution, and observability while still letting individual teams own domain-specific commands.
I’d use a thin internal CLI platform with strong conventions:
┌─────────────────────────┐
│ Company CLI │
│ `acme ...` │
└────────────┬────────────┘
│
┌────────────────┼────────────────┐
│ │ │
`acme dev` `acme cloud` `acme data`
│ │ │
Team-owned Team-owned Team-owned
commands commands commands
│ │ │
└────────────────┼────────────────┘
│
┌────────────┴────────────┐
│ Shared CLI platform │
├────────────────────────┤
│ auth / config │
│ logging / telemetry │
│ output / errors │
│ API clients │
│ completion / docs │
│ update / installation │
└─────────────────────────┘
Before picking technology, define conventions that every CLI must follow.
For example:
acme <domain> <verb> [resource]--help always works--version always works--json for automation--quiet / --verbose--yesThis is more important than whether you use Go, Rust, Python, etc. A CLI framework such as Cobra explicitly treats the CLI as a user interface, including discoverability, help, completion, and logical command hierarchies.
Create a small CLI SDK that provides the boring-but-critical pieces:
cli-platform/
auth
config
logging
output
errors
telemetry
prompts
http
pagination
completion
versioning
Then a team building acme deploy shouldn't reinvent authentication, API retries, JSON formatting, or error handling.
I'd make the platform intentionally opinionated. If every team can override everything, you've effectively created 30 independent CLIs again.
For most companies, I'd start with:
tools/
acme/
cmd/
dev/
cloud/
data/
deploy/
internal/
pkg/
docs/
or, if teams need independent release cycles:
cli-platform/
cli-dev/
cli-cloud/
cli-data/
with a common SDK and standardized project template.
A CLI generator/scaffolder is particularly valuable:
acme-cli new inventory
which generates a command with the company's defaults already wired in.
Cobra, for example, provides a command generator and built-in support for nested commands, flags, help generation, aliases, shell completion, and man pages.
I'd publish a short CLI Style Guide.
For example:
| Concern | Company standard |
|---|---|
| Commands | verb/resource convention |
| Flags | GNU-style long flags |
| Output | human by default, --json for automation |
| Errors | actionable, stable error codes |
| Auth | shared credential mechanism |
| Config | standard locations + env vars |
| Confirmation | required for destructive operations |
| Logging | stderr |
| Exit codes | documented and consistent |
| Completion | Bash/Zsh/Fish/PowerShell |
| Versioning | SemVer + compatibility policy |
| Deprecation | warning → migration period → removal |
The important bit is that CLI behavior becomes an API contract. Changing acme deploy --environment prod is potentially just as breaking as changing an HTTP API.
This is one of the biggest differentiators between a pleasant internal CLI ecosystem and a pile of scripts.
For example:
acme cloud instances
might produce:
NAME REGION STATUS
web-01 us-east-1 running
web-02 us-east-1 running
while:
acme cloud instances --json
produces stable JSON.
Then automation can safely do:
acme cloud instances --json | jq '.[] | select(.status == "running")'
Don't make users scrape pretty terminal output.
I'd maintain a registry like:
Command Owner Lifecycle API
acme cloud Platform Stable v2
acme deploy Developer Exp. Stable v3
acme data Data Platform Beta v1
acme legacy Infrastructure Deprecated -
Every command should have:
This prevents the classic internal-tool problem where something nobody remembers writing becomes business-critical.
Don't make users install:
pip install foo
npm install bar
curl .../script.sh | bash
go install ...
depending on which team created the tool.
Give them one installation/update mechanism:
brew install acme/tap/acme
or:
acme self-update
and ideally:
acme doctor
for diagnosing environment/auth/configuration problems.
For broad developer distribution, Go or Rust are particularly attractive because they can produce self-contained binaries. If you're a Go-heavy organization, Cobra is a particularly natural choice and is already used by projects including Kubernetes, Docker, and GitHub CLI.
If you're a Rust shop, clap is an excellent equivalent; it provides declarative/procedural argument parsing and polished help, suggestions, colors, and shell completion.
I'd have a small CLI Working Group rather than a central team that owns every command.
The working group owns:
Individual teams own:
That gives you central consistency without central bottlenecking.
For a typical 100–5,000-person engineering organization, I'd start with:
Language: Go CLI framework: Cobra Config: environment + standard config file, with one shared configuration library Output: human + JSON modes Auth: centralized credential/token library Distribution: signed binaries + package-manager integration Docs: generated command reference + conceptual guides Telemetry: opt-in/appropriate internal telemetry Governance: lightweight CLI Working Group Architecture: one top-level company CLI, with independently owned command domains
Cobra's command-tree architecture is particularly well suited to this model because commands can map naturally onto organizational/business domains while keeping command definitions separate from business logic for testing.
The key architectural rule I'd enforce is:
Teams own commands; the platform team owns the experience. That gives you consistency without turning the CLI platform team into a ticket queue.
I'd also roll this out incrementally:
acme <domain> <command>.I would not jump directly to Level 4. The biggest early win is establishing the command/UX contract and eliminating duplicated infrastructure; the organizational governance can follow once people are actually using the platform.
Language: Go CLI framework: Cobra Config: environment + standard config file, with one shared configuration library Output: human + JSON modes Auth: centralized credential/token library Distribution: signed binaries + package-manager integration Docs: generated command reference + conceptual guides Telemetry: opt-in/appropriate internal telemetry Governance: lightweight CLI Working Group Architecture: one top-level company CLI, with independently owned command domains
Cobra's command-tree architecture is particularly well suited to this model because commands can map naturally onto organizational/business domains while keeping command definitions separate from business logic for testing.
The key architectural rule I'd enforce is:
Teams own commands; the platform team owns the experience. That gives you consistency without turning the CLI platform team into a ticket queue.
If you're a Rust shop, clap is an excellent equivalent; it provides declarative/procedural argument parsing and polished help, suggestions, colors, and shell completion.
I'd publish a short CLI Style Guide.
For example:
| Concern | Company standard |
|---|---|
| Commands | verb/resource convention |
| Flags | GNU-style long flags |
| Output | human by default, --json for automation |
| Errors | actionable, stable error codes |
| Auth | shared credential mechanism |
| Config | standard locations + env vars |
| Confirmation | required for destructive operations |
| Logging | stderr |
| Exit codes | documented and consistent |
| Completion | Bash/Zsh/Fish/PowerShell |
| Versioning | SemVer + compatibility policy |
| Deprecation | warning → migration period → removal |
The important bit is that CLI behavior becomes an API contract. Changing acme deploy --environment prod is potentially just as breaking as changing an HTTP API.
This is one of the biggest differentiators between a pleasant internal CLI ecosystem and a pile of scripts.
For example:
acme cloud instances
might produce:
NAME REGION STATUS
web-01 us-east-1 running
web-02 us-east-1 running
while:
acme cloud instances --json
produces stable JSON.
Then automation can safely do:
acme cloud instances --json | jq '.[] | select(.status == "running")'
Don't make users scrape pretty terminal output.
I'd maintain a registry like:
Command Owner Lifecycle API
acme cloud Platform Stable v2
acme deploy Developer Exp. Stable v3
acme data Data Platform Beta v1
acme legacy Infrastructure Deprecated -
Every command should have:
This prevents the classic internal-tool problem where something nobody remembers writing becomes business-critical.
Don't make users install:
pip install foo
npm install bar
curl .../script.sh | bash
go install ...
depending on which team created the tool.
Give them one installation/update mechanism:
brew install acme/tap/acme
or:
acme self-update
and ideally:
acme doctor
for diagnosing environment/auth/configuration problems.
For broad developer distribution, Go or Rust are particularly attractive because they can produce self-contained binaries. If you're a Go-heavy organization, Cobra is a particularly natural choice and is already used by projects including Kubernetes, Docker, and GitHub CLI.
If you're a Rust shop, clap is an excellent equivalent; it provides declarative/procedural argument parsing and polished help, suggestions, colors, and shell completion.
A good way to think about this is **“CLI platform,” not “a collection of scripts.”** The goal is to make every company CLI feel like it belongs to the same product family: predictable commands, consistent configuration, authentication, output, errors, installation, telemetry, and lifecycle. ### A practical framework…
A good way to think about this is “CLI platform,” not “a collection of scripts.” The goal is to make every company CLI feel like it belongs to the same product family: predictable commands, consistent configuration, authentication, output, errors, installation, telemetry, and lifecycle.
I’d use a 5-layer model:
| Layer | Standardize | Example |
|---|---|---|
| 1. UX contract | Naming, verbs, flags, output, errors | company deploy, company logs, company env |
| 2. Shared runtime | Auth, config, HTTP, retries, logging, telemetry | One internal CLI SDK |
| 3. Command implementations | Business-specific functionality | company kubernetes, company data, company cloud |
| 4. Distribution | Install, update, versioning, compatibility | Homebrew/package manager + signed binaries |
| 5. Governance | Ownership, reviews, deprecation, metrics | CLI standards + platform team |
The important architectural decision is to centralize the cross-cutting concerns but decentralize domain commands.
For example:
company
├── auth
├── config
├── doctor
├── version
├── deploy
├── cloud
│ ├── accounts
│ └── resources
├── data
│ ├── query
│ └── warehouse
└── dev
├── bootstrap
└── environment
The user should not need to know which team owns company data query. They should experience it as one coherent CLI.
Write down rules such as:
noun verb or verb noun—pick one and stick to it.get, list, create, delete, deploy, logs, describe.--json produces machine-readable output.--help.This is arguably more important than the underlying framework.
Instead of every team implementing authentication differently:
cli-platform/
├── auth/
├── config/
├── output/
├── errors/
├── http/
├── telemetry/
├── update/
├── permissions/
└── testing/
Then a domain team primarily writes:
commands/
└── deploy/
├── create
├── status
└── rollback
The platform owns the boring-but-critical pieces.
This is similar to the golden-path/self-service model used in internal developer platforms: the platform should reduce cognitive load rather than force every team to reinvent infrastructure. AWS explicitly recommends treating an internal developer platform as a product, with self-service capabilities and standardized golden paths.
If you're starting from scratch and have a mixed engineering organization, I'd strongly consider Go for the company-wide CLI.
A Go binary gives you particularly attractive distribution characteristics: compiled binaries don't require users to have Python/Node/etc. installed, and Go supports straightforward cross-platform builds.
For the command framework, Cobra is a strong default. It supports nested subcommands, global/local flags, generated help, shell completion, aliases, and documentation generation. It's also used by projects such as Kubernetes, Docker, and GitHub CLI.
If your organization is heavily Python-oriented, Typer is a reasonable alternative; it uses Python type hints and provides automatic help and shell completion.
I'd avoid having every team independently choose between Cobra, Click, Typer, Node CLI frameworks, Bash, etc. One sanctioned default + an exception process is much easier to manage.
This is a big one.
Don't build:
command handler
↓
business logic
↓
API
Build:
CLI
↓
Application/service layer
↓
API/client libraries
↓
Backend
That means you can eventually expose the same capabilities through:
The CLI becomes an interface, rather than where your business logic lives.
Once employees start putting your CLI into scripts and CI pipelines, CLI behavior becomes an API.
I'd explicitly version:
And establish rules like:
Adding commands is backwards compatible. Removing/renaming commands requires deprecation. Changing JSON schemas requires versioning.
For example:
company deploy create my-service
company deploy status my-service --json
could guarantee that --json has a documented schema, while the pretty terminal output is allowed to evolve.
A great company CLI should have:
brew install company/tap/company
or your organization's equivalent, followed by:
company auth login
company doctor
company version
I'd provide:
Cobra can generate shell completion for Bash, Zsh, Fish, and PowerShell, which is useful for establishing a consistent experience across platforms.
The organizational model matters as much as the code.
I'd establish a small CLI Platform team responsible for:
Platform owns
Domain teams own
This avoids the two bad extremes:
Centralized everything: platform becomes a bottleneck.
Decentralized everything: foo, bar, and baz all develop completely different CLIs.
This is one of my favorite pieces of the model.
Every CLI/command package gets automatically tested against a company standard:
✓ --help exists
✓ --version exists
✓ --json works
✓ errors go to stderr
✓ exit codes conform
✓ shell completion generated
✓ authentication uses company SDK
✓ telemetry uses company SDK
✓ secrets aren't printed
✓ command documentation exists
✓ backwards compatibility tests pass
You can make this a CI gate.
That turns your standards from a document people forget into an executable contract.
Don't just measure downloads.
Track:
Then the platform team can answer:
"Why are people still using the old deployment script?"
instead of merely publishing a new CLI and hoping adoption happens.
┌──────────────────────┐
│ Company CLI UX │
│ commands / flags / UX │
└──────────┬───────────┘
│
┌──────────▼───────────┐
│ CLI Platform SDK │
│ auth │
│ config │
│ output │
│ errors │
│ HTTP │
│ telemetry │
│ update │
└──────────┬───────────┘
│
┌────────────────────┼────────────────────┐
▼ ▼ ▼
Cloud commands Data commands Dev commands
│ │ │
└────────────────────┼────────────────────┘
▼
Company APIs/services
In short: standardize the experience and platform, not necessarily every line of implementation. Give teams autonomy over domain commands, but make authentication, configuration, output, errors, distribution, observability, and compatibility boringly consistent.
If I were implementing this today, I'd probably choose Go + Cobra + a shared internal CLI SDK + a conformance test suite + a platform team, and treat the resulting CLI as an internal product rather than developer tooling.
Building a robust, company-wide Command Line Interface (CLI) ecosystem requires treating your internal CLIs like actual products rather than quick shell scripts. A strong framework covers everything from developer experience to distribution and…
Building a robust, company-wide Command Line Interface (CLI) ecosystem requires treating your internal CLIs like actual products rather than quick shell scripts. A strong framework covers everything from developer experience to distribution and governance.
Here is a comprehensive framework for building and managing a consistent, company-wide set of CLI tools, broken down into five core pillars:
If you'd like, we can dive deeper into any of these areas:
Choosing the best programming language/framework for your team's stack Designing a distribution and auto-update workflow using GitHub Actions/GitLab CI Drafting an internal style guide for flags, outputs, and errors
A scalable framework for building and managing a company-wide toolchain centers on a **Unified Plugin Architecture (inspired by `kubectl` or HashiCorp CLIs** **)** paired with static-binary distribution and declarative version locking. Instead of maintaining fragmented, standalone scripts across different…
A scalable framework for building and managing a company-wide toolchain centers on a Unified Plugin Architecture (inspired by kubectl or HashiCorp CLIs ) paired with static-binary distribution and declarative version locking. Instead of maintaining fragmented, standalone scripts across different repositories, organizations implement a single core parent CLI (e.g., company ) that dynamically discovers, updates, and executes modular sub-commands and plugins written by individual product or infrastructure teams.
Core Architecture & Tooling Stack
--json, --quiet ), and an automatic plugin dispatcher that routes company <plugin-name> <args> to underlying binaries.company k8s restart ), standardized exit codes (0 for success, clear non-zero codes for specific failures), machine-readable JSON outputs for pipelining, and human-readable logging directed exclusively to stderr.Management, Distribution, and Lifecycle
If you'd like to narrow this down, let me know:
I can help draft a sample repository structure or manifest template for your team.
A good company-wide CLI framework is less about the argument-parsing library and more about **governance, architecture, distribution, and UX consistency**. Treat the CLI as an internal product/platform rather than a collection of scripts. Internal developer platforms tend to succeed when they provide self-service…
A good company-wide CLI framework is less about the argument-parsing library and more about governance, architecture, distribution, and UX consistency. Treat the CLI as an internal product/platform rather than a collection of scripts. Internal developer platforms tend to succeed when they provide self-service "golden paths," clear conventions, and a product mindset.
A strong framework looks something like this:
Use one top-level command:
acme auth login
acme service create
acme env start
acme deploy staging
acme logs api --since 1h
Avoid:
deploy-prod.sh
create-service.py
kubectl-wrapper
aws-helper
The central CLI becomes the discovery mechanism:
acme help
acme plugins list
acme doctor
A single entry point reduces cognitive load and makes common workflows discoverable.
Keep the core small:
acme
├── auth
├── config
├── update
├── plugin
└── version
Then allow teams to add domains:
acme
├── kubernetes
├── terraform
├── data
├── security
├── mobile
└── payments
Possible models:
The core discovers executables:
acme-terraform
acme-kubernetes
acme-data
Running:
acme terraform plan
delegates to:
acme-terraform plan
Advantages:
Example:
acme plugin install payments
acme plugin update
The CLI manages versions from an internal registry.
Pick rules and enforce them.
Example:
acme <noun> <verb> [options]
Good:
acme service create
acme service delete
acme service list
Avoid:
acme make-service
acme rm-service
acme services-show
Standardize:
create, delete, list, get, update)--output, --json, --verbose)Consistency matters more than individual command elegance.
A company CLI serves:
Design for both:
Human:
$ acme service list
NAME STATUS
payments running
catalog running
Machine:
$ acme service list --json
{
"services": [
{"name":"payments","status":"running"}
]
}
Good conventions:
Structured output and predictable behavior make CLIs much easier to automate.
Don't make every team solve the same problems.
Your SDK should provide:
cli-framework/
├── authentication
├── config loading
├── logging
├── telemetry
├── output formatting
├── retries
├── API clients
├── error handling
└── testing helpers
Example:
from acme_cli import command, output
@command("service create")
def create_service(name):
output.success(f"Created {name}")
Common choices:
| Language | Framework | Best fit |
|---|---|---|
| Go | Cobra CLI | Enterprise CLIs, single binaries |
| Python | Typer / Click | Data/platform teams |
| TypeScript | oclif | Plugin-heavy ecosystems |
| Rust | clap | Fast native tools |
The framework choice matters less than the conventions you put around it. Mature CLI frameworks generally help with help text, parsing, completions, and packaging.
A great CLI should be:
curl install.acme.com | sh
or:
brew install acme-cli
and support:
acme update
Typical enterprise setup:
Artifact Registry
|
v
acme-cli releases
|
v
developers' machines
Include:
A common failure mode is a "miscellaneous CLI graveyard."
Define:
Every command should have:
✓ --help
✓ examples
✓ documentation
✓ unit tests
✓ integration tests
✓ JSON output
✓ predictable exit codes
✓ backwards compatibility policy
Developer
|
v
acme CLI
|
+-------------+-------------+
| | |
Core Plugins SDK
| | |
auth/config team commands shared libs
updates deploy tools API clients
telemetry generators formatting
A good first version is usually:
The biggest mistake is trying to build "the CLI that does everything." The better pattern is a stable core + opinionated conventions + extensible plugins.
A good way to think about this is **“CLI platform,” not “a collection of scripts.”** The goal is to make every internal CLI feel like the same product, while allowing individual teams to own domain-specific commands. I’d use a **layered framework**: ```text
A good way to think about this is “CLI platform,” not “a collection of scripts.” The goal is to make every internal CLI feel like the same product, while allowing individual teams to own domain-specific commands.
I’d use a layered framework:
┌─────────────────────────┐
│ Company CLI (`acme`) │
└────────────┬────────────┘
│
┌───────────────────┼───────────────────┐
▼ ▼ ▼
acme deploy acme cloud acme data
│ │ │
└──────────────┬────┴───────────────────┘
▼
Shared CLI platform
┌──────────────────────────────┐
│ auth / config / logging │
│ output / errors / telemetry │
│ API clients / permissions │
│ versioning / update mechanism│
└──────────────┬───────────────┘
▼
Company APIs/services
Prefer:
acme deploy
acme env create
acme service list
acme secrets get
acme logs tail
over having 25 unrelated binaries:
deploy-tool
envctl
service-cli
secret-manager
logtail
...
The important thing isn't necessarily one executable technically. You can have independently developed plugins behind acme, but users should have one discovery mechanism, one authentication model, one configuration model, and one UX vocabulary.
Write a short RFC/specification covering things like:
Command structure
<product> <resource> <verb> [arguments] [flags]
For example:
acme service create payments
acme service get payments
acme service deploy payments --env=production
Universal flags
--help
--version
--output=json
--quiet
--verbose
--profile=<name>
Exit codes
Define them centrally rather than letting every team invent them.
Output
Human-readable output should be pleasant:
NAME STATUS VERSION
payments healthy v2.18.4
billing degraded v1.9.1
but automation should have deterministic structured output:
acme service list --output=json
This becomes particularly valuable as CLIs are increasingly consumed by automation and AI agents; recent research and practitioner discussion both point toward CLI interfaces being useful precisely because they're deterministic, composable interfaces.
This is probably the most important architectural rule.
Don't do:
command → API calls → business logic
Instead:
command
↓
CLI/application layer
↓
shared domain/client libraries
↓
API
For example:
cmd/service/deploy
↓
ServiceClient.Deploy(...)
↓
Platform API
That means you can later build:
CLI ───────┐
├── ServiceClient
Web UI ────┤
│
Automation ┘
without duplicating behavior.
This is where consistency really comes from.
Have a centrally maintained library providing:
Then individual CLI teams mostly implement:
What does `acme foo ...` actually do?
rather than repeatedly solving:
How do we authenticate?
How do we format errors?
How do we output JSON?
How do we find credentials?
How do we handle Ctrl-C?
I'd use a platform + federated ownership model.
| Area | Owner |
|---|---|
| CLI framework | Developer Platform |
| UX conventions | Developer Platform |
| Authentication | Security/Platform |
| Distribution | Developer Platform |
acme deploy | Deployment team |
acme service | Platform team |
acme data | Data team |
| Individual API integrations | Owning service team |
The platform team owns the paved road, not every command.
This avoids the two classic failures:
Centralized failure: one team becomes a bottleneck for every new command.
Federated failure: every team creates its own mini-CLI ecosystem.
A beautiful CLI nobody can install isn't a platform.
Ideally:
brew install acme
or an equivalent company-managed installation mechanism, with:
acme update
acme version
and automatic or centrally managed upgrades.
For larger organizations, I'd also have CI produce binaries/packages for your supported OS/architectures and publish them to an internal artifact registry.
Don't start by building an elaborate plugin system.
Initially:
acme
├── auth
├── service
├── deploy
└── env
Later, if teams genuinely need independent release cycles:
acme
├── core
├── service plugin
├── cloud plugin
├── data plugin
└── security plugin
The important abstraction is:
shared runtime + independently owned command modules
rather than necessarily having one monolithic repository.
If you have something like Backstage, make the CLI part of the broader developer platform rather than a standalone project. Backstage's Software Catalog and Templates are explicitly designed to centralize software information and standardize how teams create new components.
For example:
acme service create payments
could ultimately be backed by the same templates/catalog metadata that your internal portal exposes.
That gives you a useful relationship:
Developer Platform
│
┌─────────────┴─────────────┐
│ │
Web UI CLI
│ │
└─────────────┬─────────────┘
│
Platform APIs
Backstage itself is an interesting example of this pattern: its CLI provides common lifecycle commands while its templates allow organizations to customize standardized creation workflows.
I'd make every company CLI pass a small automated conformance suite:
✓ --help works
✓ --version works
✓ shell completion works
✓ JSON output works
✓ predictable exit codes
✓ no credentials in output
✓ Ctrl-C handled correctly
✓ errors are actionable
✓ commands have documentation
✓ commands have integration tests
✓ supports company authentication
✓ follows naming conventions
✓ telemetry/privacy requirements satisfied
You can even have:
acme lint-cli ./my-plugin
That turns your conventions into something enforceable rather than a document everyone forgets.
Useful metrics include:
The last metric is particularly revealing: adding a new company CLI command should become boring.
If I were starting from scratch, I'd make these five layers:
company executable and common UX.And I'd govern it with three artifacts:
That combination tends to scale much better than trying to create a giant "internal CLI framework" where every possible capability is centralized.
The key principle: standardize the experience and infrastructure, not ownership of the business capabilities.
If you're choosing the actual implementation stack, Go is a particularly strong fit for a company-wide CLI because static binaries make distribution across macOS/Linux/Windows relatively straightforward; Cobra is a common choice for command composition, although the architectural separation above matters considerably more than which CLI library you choose.
Building a robust, company-wide Command Line Interface (CLI) ecosystem requires treating your internal tools with the same rigor as production software services. A solid framework spans governance, developer experience (DevEx), and…
Building a robust, company-wide Command Line Interface (CLI) ecosystem requires treating your internal tools with the same rigor as production software services. A solid framework spans governance, developer experience (DevEx), and distribution.
--config, --verbose, --json ), and exit codes (0 for success, non-zero for specific errors).Would you like me to dive deeper into choosing a specific programming language for your stack, or outline a CI/CD pipeline for cross-platform distribution?