very_good_cli renames three of its four verbs for MCP callers
A Very Good Command-Line Interface for Dart created by Very Good Ventures 🦄
At a glance
- What is it?
- very_good_cli is a Dart generator for Dart and Flutter project templates with commands for testing, package installation and license checks. Its MCP server renames the verbs it exposes, three of the help blocks on the page stop mid-sentence, and the example directory contains a README and nothing else.
- Who is it for?
- very_good_cli suits a Dart or Flutter team that wants a generated project skeleton with the analysis and test configuration already set up, and that runs inside CI where a global activate is awkward. Before adopting it, decide how you will invoke it, since the package name, the installed executable and the global run form are three different spellings of the same tool.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly Dart, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- VeryGoodOpenSource/very_good_cli2,430 ★ · +5
| Repository | 2026-09-30 | 2026-11-15 |
|---|---|---|
| VeryGoodOpenSource/very_good_cli | 2.4k | 2.4k |
5 Stars in the last 46 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The package, the executable and the global run form have three names
Installation is one command, and the names around it are worth writing down:
dart pub global activate very_good_cliThe package is `very_good_cli`, while the executable you then type is `very_good`. A version argument is accepted by the same command if you want to pin one. Activating globally puts that executable somewhere on your pub cache bin directory, which is why the page links to path setup afterwards and tells you you might need it. Then it gives the case that path setup cannot fix:
dart pub global run very_good_cli:very_good <command> <args>That form is the one to use in CI environments, and it has to name the package and the executable separately, `very_good_cli:very_good`, because nothing is on the PATH to resolve the short name. So the same tool has two spellings depending on who runs it, and the long form is the only one that works where nothing was installed to a PATH you control.
Three of the four help blocks on the page stop mid-sentence
The command reference is mostly quoted terminal output, and three of the blocks are unfinished. The `very_good create` help text ends partway through the last entry of its subcommand list, at `Generate a Very Good Flutter p`. The usage examples below it end on a truncated command, `very_good create flame_g`. The global help block, which is the one that lists every command and the global options, ends mid-sentence on the experimental warning for the MCP command: `WARNING: This is an experimental package and may change or become unstable without notice. Use it`. The test, packages and MCP blocks are complete. The pattern is unfortunate in a specific way, because the global help is the block a newcomer reads first and the create block is the one they copy first, and both are the cut ones. The complete blocks are the two you are least likely to need while learning the tool.
The MCP surface renames three of the four verbs
The `very_good mcp` command starts a Model Context Protocol server so an assistant can drive the tool programmatically, and it is marked experimental with a warning that it relies on the Dart MCP Server, may change or become unstable without notice, and should be used with caution at your own risk. Four tools are exposed: `create`, `tests`, `packages_check_licenses` and `packages_get`. Compare that with what you type. The CLI spells them `create`, `test` in the singular, `packages check licenses` in two words and `packages get` in two words. So an agent calling by tool name cannot reuse a single CLI spelling: one verb gains an s, one becomes a snake case pair, one swaps its word order, and only `create` survives unchanged. The page does not say whether the names are stable while the feature is experimental.
License checking takes an allow list and a deny list at once
The dependency command is the most configurable on the page, and the flags interact:
very_good packages check licenses --allowed="MIT,BSD-3-Clause,BSD-2-Clause,Apache-2.0"
very_good packages check licenses --forbidden="unknown"
very_good packages check licenses --dependency-type="direct-main,transitive"
very_good packages check licenses --reporter="csv"One flag restricts the set of licenses you accept, another names licenses you reject, a third chooses which dependency classes to walk, with direct and transitive named as the example, and the fourth changes the output format. That is a policy checker rather than a linter with a fixed opinion, which is the useful part: the allow list in the example is four licenses and the deny list is the single token `unknown`, so the two examples are complementary rather than alternatives. The sibling command, `very_good packages get`, does the same directory and recursion handling as the test command, accepting a path and a `--recursive` or `-r` shorthand.
Full coverage is an option you pass, not a default you get
The test command carries the flags a Dart or Flutter project usually wants, and one of them encodes a policy:
very_good test --coverage --min-coverage 100`--coverage` collects coverage and `--min-coverage 100` is what enforces a hundred percent threshold, so the strict setting is opt in rather than what the command assumes. The rest are convenience: a positional path so you can point the runner at `./some/other/directory`, `--recursive` with the `-r` shorthand for the same thing, and `--platform chrome` to run against a specific platform. The create command takes its own set of inputs, with `--desc` for a description, `--org` for a custom organisation and `--application-id` for a custom application identifier. The page does not say how those values propagate into the generated project's identifiers, which is the part you would want to know before generating into an existing namespace.
Coverage is a committed file and the example directory holds no code
The repository keeps its own coverage number as an artefact. `coverage_badge.svg` sits at the root, and the coverage badge in the header is not a service query but a direct link to that file on the raw content host at the `main` branch, so the number in the header is whatever the last run wrote into the repository. The continuous integration badge uses the older workflow named form, a path ending in `workflows/very_good_cli/badge.svg`, which names the workflow rather than the file. Releases are handled by tooling as well, with a release please configuration and a release please manifest at the root alongside CHANGELOG.md and ROADMAP.md. And the `example/` directory contains one file, `example/README.md`. A project template tool with an example directory that holds no example is worth knowing before you look for a reference implementation there.
A Dart CLI that also carries a Mason brick
The repository serves two roles at once, and the root shows both. The executable lives in `lib/` and `bin/`, with `dart_test.yaml` for the test runner configuration, `build.yaml` for build time code generation, `e2e/` for end to end tests and `tool/` for repository scripts. Alongside that, `mason.yaml` and a `bricks/` directory make the same templates available to the Mason generator, so the templates are described twice, once as Dart code that writes files and once as a brick definition for another tool to consume. The documentation site has its own `site/` directory and the prose has `doc/`, which is why the page's links all point at cli.vgv.dev rather than at files in the tree. `analysis_options.yaml` carries the analysis configuration the style badge refers to, and `.lycheeignore` at the root is a link checker exclusion list, which is what keeps a generated site full of absolute URLs from failing a check.
Editorial conclusion
very_good_cli suits a Dart or Flutter team that wants a generated project skeleton with the analysis and test configuration already set up, and that runs inside CI where a global activate is awkward. Before adopting it, decide how you will invoke it, since the package name, the installed executable and the global run form are three different spellings of the same tool. Read the MCP server section before enabling it for an agent, because the page marks it experimental at your own risk and the tool names an agent would call are not the names you type. Pin a version if reproducibility matters to you, since the activate command accepts one and the default is whatever the package registry serves.
Frequently asked questions
How do I install very_good_cli?
Run `dart pub global activate very_good_cli`, optionally with a version argument to pin one, and set up your PATH if it is not already reachable. Where PATH setup is not possible, such as in CI, the page gives `dart pub global run very_good_cli:very_good <command> <args>` as the fallback.
What project templates does very_good create support?
Each template is its own subcommand: app_ui_package, dart_cli, dart_package, docs_site, flame_game, flutter_app and flutter_package. The create command also takes `--desc` for a description, `--org` for a custom organisation and `--application-id` for a custom application identifier.
How do I run tests with coverage using very_good?
`very_good test --coverage` collects coverage and `--min-coverage 100` is what enforces a full threshold, so strictness is opt in. The command also accepts a directory path, `--recursive` with the `-r` shorthand, and `--platform chrome` to target one platform.
What does very_good mcp do?
It starts a Model Context Protocol server so AI assistants can drive the CLI programmatically. The page marks it experimental, notes it relies on the Dart MCP Server and may change or become unstable without notice, and lists four tools: create, tests, packages_check_licenses and packages_get.
Can very_good check the licenses of my dependencies?
Yes. `very_good packages check licenses` accepts `--allowed` with a comma separated list such as MIT, BSD-3-Clause, BSD-2-Clause and Apache-2.0, `--forbidden`, `--dependency-type` for classes such as direct-main and transitive, and `--reporter=csv` to list the result instead of checking it silently.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/verygoodopensource-very-good-cli)Star history chart for your README
[](https://hysenlabs.com/projects/verygoodopensource-very-good-cli)Was this useful?