You know the feeling. You merge a PR that passed every review, ran all checks, and looked clean. Three weeks later, you discover a dependency that crossed the wrong boundary. Now you’re untangling a knot that costs your team two sprints. That’s not a bug—that’s architectural drift. And it’s the silent killer of every growing codebase.
Architecture enforcement shouldn’t be a post-mortem exercise. It should be a compiler error.
Most teams treat architecture like a guest list—vague guidelines you hope people follow. But hope isn’t a strategy. By the time your CI pipeline runs, the damage is already committed. The fix? Stop reacting. Start preventing. That’s exactly what Onboard-CLI does.
Built in Go, this tool uses Tree-sitter AST parsing to map your entire codebase structure in under 10 seconds—even with 50,000+ files. It doesn’t just scan for string patterns; it understands the actual semantics of your code. It knows which module depends on which, which classes are allowed to call which functions, and where the forbidden cross-dependencies lurk. Then it blocks them before you even type git commit.
Let me tell you a story. At a former startup, we had a clean modular architecture on day one. By month six, the boundaries were a fantasy. No one intentionally broke them—it just happened. One dev needed a quick function from another module, another imported a utility from the wrong layer. Each violation was tiny, but they piled up into a spaghetti ball. We spent a quarter refactoring. Onboard-CLI would have caught every single violation at the moment of typing. No refactor needed.
Speed without semantic accuracy is just noise. Onboard-CLI gives you both.
Here’s the twist you don’t expect: To make this tool fast enough for local development, you’d think you’d have to cut corners. Parse AST? That’s slow. But the creators optimized concurrency like maniacs. The result is a tool that runs in the background, instant feedback, zero friction. It doesn’t slow you down—it makes you faster by eliminating the anxiety of future breakage.
Take a side: Architecture is either a suggestion or a guarantee. If you treat it as a suggestion, your codebase will rot. This tool makes it a guarantee—a compiler-level constraint that runs locally, before anything hits the repo. No more CI post-mortems. No more ‘we’ll fix it later.’ Because later never comes.
You’ve probably felt the frustration of merging code that later breaks architecture boundaries. You’ve watched your beautiful modular design turn into a dependency hell. Onboard-CLI is the cure. It turns architecture from a wish into a fact. Stop waiting for your CI to tell you what you already know. Start enforcing architecture the moment you write it. Your future self will thank you.
FAQ
Q: Isn't this just another linter? Why not use ESLint or similar?
A: Traditional linters enforce formatting and basic patterns, but they can't understand architectural boundaries like module isolation or dependency direction. ESLint works on abstract syntax trees, but only for JavaScript/TypeScript and with limited scope. Onboard-CLI is language-agnostic (via Tree-sitter) and focuses specifically on structural relationships—who can depend on whom, what belongs where. It's a different layer of enforcement.
Q: What's the practical implication for a team adopting this?
A: Teams catch violations while coding, not after merging. That means zero architectural tech debt from day one, faster code reviews (reviewers don't need to check module boundaries), and dramatically reduced refactoring costs. Over a year, it can save weeks of cleanup work.
Q: Isn't rigid architecture enforcement a bad thing? Shouldn't teams be allowed to evolve?
A: The tool is fully configurable—you define the rules. You're not locking in a static architecture; you're making intentional violations visible. If a cross-boundary dependency is justified, you can whitelist it explicitly. The goal is to prevent accidental drift, not to kill flexibility. It's about making decisions conscious, not banning change.