bit's first command asks for a scope, and its default build is hosted
AI-powered development workspaces with reusable components, architectural clarity and zero overhead.
At a glance
- What is it?
- Bit is a TypeScript component platform that organises source into reusable components, composes them into application shells, and exports them as ordinary npm packages, and its own source is built with itself. What the getting started path reveals is the shape of the dependency on the vendor: the first local command requires a scope that the README tells you to create on the Bit platform, and component builds default to Ripple CI unless you pass a flag.
- Who is it for?
- Bit fits a team with several applications that share UI and backend code and wants those pieces versioned and consumed through the package manager it already uses, since the end state is a normal npm specifier rather than a proprietary import. It does not fit a team that wants every step to run locally without an account, because the documented first command assumes a scope on the vendor's platform and the default build runs on the vendor's CI.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly TypeScript, 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
- teambit/bit18,507 ★ · +24
| Repository | 2026-09-16 | 2026-11-15 |
|---|---|---|
| teambit/bit | 18.5k | 18.5k |
24 Stars in the last 60 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The first local command asks for a scope you are told to create in the cloud
Installation is a version manager rather than a global package:
npx @teambit/bvm installThen initialisation, and this is the line that shapes the whole onboarding path:
bit init --default-scope my-org.my-projectThe very next sentence in the README is make sure to create your scope on the Bit platform and use the right org and project name.
So the first thing the tool does to a new folder is bind it to an identifier, and the README's instruction is that the identifier already exists on the vendor's hosted service. Nothing about that is wrong, and the later release section does say you can host scopes on your own with a reference page for running a scope server. But the documented path presents the hosted scope as the default and the self-hosted one as an alternative discovered further down.
For a reader evaluating a component platform, that ordering is the thing to notice. The unit of everything Bit does is a scope, and a scope is a hosted object before it is a local one.
Component builds default to Ripple CI, and the escape hatch is a flag
The release section says one thing that a reader should not skip: by default, Bit uses Ripple CI to build components, and you can use the `--build` flag to build the components on the local machine.
So the default build of a unit of code happens on a hosted service from the same vendor, and moving it local is a flag rather than a configuration. The section also offers a third path, tagging and exporting from a CI of your choice to automate the release process, or using the official CI scripts.
Three arrangements therefore exist: Ripple CI by default, a local build with a flag, and your own pipeline with the provided scripts. The repository reflects the third option, because the top level carries a `.circleci/` directory and a `.circle-sha` file, and the manifest has a script that emits lint results in JUnit XML for exactly that system.
So a team can avoid the vendor's CI, and there is committed configuration for a well-known third-party CI. What they cannot avoid is the scope object, and the hosted default is worth naming when you compare options.
The end state is an ordinary npm package name
The strongest interoperability claim in the README is not about components at all. It is the last line of the getting started path, after versioning and exporting, where the component is installed with:
npm install @my-org/users.pages.loginAnd the same specifier is what application code imports. The composition example builds a route that takes a `Login` component from `@my-org/users.pages.login` and mounts it at `/login` beside a `Hello world` root route.
So the payoff of the whole system is that a component ends up in a normal `node_modules`, installed by the package manager the project already has, with no Bit runtime in the consuming application. The dotted specifier encodes the scope, a namespace, and the component's own path, which is what makes a piece of code portable between repositories while keeping its identity.
That is the argument to weigh. A component platform that ends at a normal dependency is easy to adopt incrementally, because nothing downstream has to know the platform exists.
A committed script rejects Ramda, and another rejects an import convention
The lint story has more in it than a type check. The full validation target is a chain of four steps:
./scripts/validate-import-named-aspects.sh && ./scripts/validate-no-ramda.sh && node scripts/validate-pkg-exist-in-pkg-json.js && npm run lintThree of those are repository policy rather than tooling. One validates an import naming convention, which implies the project has a rule about how named things are imported. One is named for the absence of a specific library and validates that Ramda is not used, so the project has ruled out a whole functional programming dependency rather than merely preferring another. The third checks that every package exists in `package.json`.
Only the fourth step is the lint itself, and that is `tsc --noEmit` followed by `oxlint --deny-warnings` across the three source directories.
The consequence is that Bit enforces architectural rules that a type checker cannot see. That is a good sign for a project that intends its conventions to survive contributions, and it is also a set of rules a new contributor will hit without a document explaining them, since the README says nothing about any of this.
The commit hook lints nine extensions and re-stages what it formats
The `lint-staged` configuration has two globs and they do different jobs.
The first is a single command, oxlint with `--deny-warnings` and `--no-error-on-unmatched-pattern`, applied to files ending in js, mjs, cjs, jsx, ts, mts, cts, tsx, vue, astro or svelte. So a TypeScript project lints Vue, Astro and Svelte files as well, and a glob that matches nothing is not treated as an error.
The second is a prettier write followed by a `git add`, applied to ts, js, jsx, tsx, css, scss, md and mdx.
Two consequences. The lint scope is considerably wider than the language the project is written in, which is a statement about what Bit's component model is meant to consume. And the commit hook does not only check: it rewrites files and re-stages them, so a commit can contain formatting you did not write, which is a pattern that recurs across these lint-staged configurations and is worth expecting rather than discovering.
There is a `--fix-dangerously` variant of the oxlint script in the root as well, alongside a plain `--fix` one and a `--fix-suggestions` chain.
There is a committed directory of skipped end-to-end tests
The top level contains `e2e/` and, next to it, `e2e-skipped/`.
A directory of end-to-end tests that are not running, kept in the repository rather than deleted, is a more useful signal than a passing badge. The tests were written, they were switched off, and the reason is presumably recorded in the history or in the commit that moved them.
That matters for an adopter because the end-to-end suite is where a component platform's integration claims are tested. A suite whose components are versioned, exported and consumed across repositories has more integration surface than an application's, and the skipped directory is where the untested part of that surface is visible.
It is also ordinary engineering hygiene rather than a criticism. Plenty of projects disable tests that are slow or flaky until someone has time, and a directory makes it visible rather than hiding it in a skip annotation. The number of entries in it is the number to look at.
The surrounding test configuration is more conventional. There is a separate Babel config for the end-to-end run, a `babel-register.js` for require-time transpilation, and a Mocha multi-reporter configuration file.
The workspace is JSONC with a committed schema, and Bit's own graph is a file
The dogfooding claim in the contributors section, that Bit is entirely built with Bit and its components can be found on Bit Cloud, is mechanical rather than rhetorical. Three root files make it true.
There is `workspace.jsonc`, the workspace definition, and `workspace-jsonc-schema.json`, its schema. So the tool's central configuration format is JSON with comments, and the schema for it is published in the repository rather than on a website, which means an editor can validate a workspace file and a reviewer can check a change to the format itself.
And there is `.bitmap`, which is Bit's own component graph, tracked in version control alongside the code it describes.
The directory layout confirms it. The lint scripts run over `scopes e2e components`, and the root also carries `docs/`, `bin/`, `fixtures/`, `contrib/`, `releases-docs/` and `typings/`.
One file is worth naming separately. `publish-legacy.md` at the root is, by its name, a document about legacy publishing.
dev-link passes a literal $1, and the suite needs a mock registry and 5 GB of heap
Two small things in the scripts are worth an adopter knowing, because both are the kind of detail that costs an afternoon.
The development link scripts are `dev-link`, which runs a Node script with `$1` as an argument, and `dev-link:windows` with the same shape.
The CircleCI test script sets a raised heap and prepares a mock registry:
cross-env NODE_OPTIONS='--no-warnings --max-old-space-size=5000' registry-mock prepare && mocha --require ./babel-registerSo the suite is told to expect up to five gigabytes of memory, and a command called `registry-mock prepare` runs first, which means the test run depends on a mocked package registry being in place. That is a deliberate hermetic setup, and it is also a prerequisite a contributor has to know about before their first run rather than discover from a failure.
Neither of these is a design problem. Both are the kind of thing a README that documents four features and a getting started path does not mention, which is where the gap between using the tool and contributing to it shows.
Editorial conclusion
Bit fits a team with several applications that share UI and backend code and wants those pieces versioned and consumed through the package manager it already uses, since the end state is a normal npm specifier rather than a proprietary import. It does not fit a team that wants every step to run locally without an account, because the documented first command assumes a scope on the vendor's platform and the default build runs on the vendor's CI. Before adopting, check three things: whether you will host the scope server yourself, which the README offers and which removes most of the dependency, whether you will pass `--build` so component builds stay local, and the repository's own conventions, since a committed script rejects the Ramda library outright and another validates how named aspects are imported.
Frequently asked questions
What is Bit?
Bit is described as a build system that connects components and applications from development to CI, organising source code into composable components so they can be reused and deployed atomically. It works in a monorepo, in a polyrepo, or with no repository at all, and it is written in TypeScript, with official environments for Node.js, React, Angular, Vue, React Native and Next.js.
How do I install and start Bit?
Run `npx @teambit/bvm install`, which is Bit's own version manager rather than a global npm package. Then `bit init --default-scope my-org.my-project`, and the README says to create that scope on the Bit platform first and use the right organisation and project name. After that `bit create react-app` makes an application shell and `bit run` starts it on port 3000.
Does Bit require Bit Cloud?
Not strictly. The README says you can either use hosted scopes on Bit Cloud or host scopes on your own, with a reference page for running a scope server. What is hosted by default is the component build, which uses Ripple CI unless you pass the `--build` flag to build on the local machine, and it also offers scripts for tagging and exporting from a CI of your choice.
How are Bit components published and consumed?
You version them with semantic versioning using `bit tag`, then `bit export` releases them, after which they are available through standard package managers. The README's example installs `@my-org/users.pages.login` from npm, and that same dotted specifier is what an application imports, so nothing downstream needs the platform at runtime.
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/teambit-bit)Star history chart for your README
[](https://hysenlabs.com/projects/teambit-bit)Was this useful?